From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from smtp.gentoo.org (dev.gentoo.org [IPv6:2001:470:ea4a:1:5054:ff:fec7:86e4]) by sourceware.org (Postfix) with ESMTP id 04B4A3858C39 for ; Sat, 15 Jan 2022 00:15:39 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 04B4A3858C39 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=gentoo.org Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=gentoo.org Received: by smtp.gentoo.org (Postfix, from userid 559) id 6AC41342DC7; Sat, 15 Jan 2022 00:15:37 +0000 (UTC) Date: Fri, 14 Jan 2022 19:15:36 -0500 From: Mike Frysinger To: newlib@sourceware.org Subject: [PATCH] newlib: update to automake-1.15 Message-ID: Mail-Followup-To: newlib@sourceware.org MIME-Version: 1.0 Content-Type: multipart/signed; micalg=pgp-sha256; protocol="application/pgp-signature"; boundary="bc8cpYMQSq8NcNIO" Content-Disposition: inline X-Spam-Status: No, score=-11.1 required=5.0 tests=BAYES_00, GIT_PATCH_0, JMQ_SPF_NEUTRAL, KAM_DMARC_STATUS, KAM_NUMSUBJECT, SPF_HELO_PASS, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: newlib@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Newlib mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Sat, 15 Jan 2022 00:15:49 -0000 --bc8cpYMQSq8NcNIO Content-Type: multipart/mixed; boundary="ySC0KhfPSntW7mR+" Content-Disposition: inline --ySC0KhfPSntW7mR+ Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: quoted-printable This matches what the other GNU toolchain projects have done already. The generated diff in practice isn't terribly large. This will allow more use of subdir local.mk includes due to fixes & improvements that came after the 1.11 release series. The only changes in here are to the README & acinclude.m4 files. All the rest are regenerated outputs. --- attaching compressed as it's way too large for the list. newlib/Makefile.in | 346 +++++---- newlib/README | 4 +- newlib/acinclude.m4 | 2 +- newlib/aclocal.m4 | 684 +++++++++++------- newlib/configure | 321 ++++++-- newlib/iconvdata/Makefile.in | 213 ++++-- newlib/iconvdata/aclocal.m4 | 684 +++++++++++------- newlib/iconvdata/configure | 321 ++++++-- newlib/libc/Makefile.in | 374 ++++++---- newlib/libc/aclocal.m4 | 684 +++++++++++------- newlib/libc/argz/Makefile.in | 224 ++++-- newlib/libc/configure | 321 ++++++-- newlib/libc/ctype/Makefile.in | 224 ++++-- newlib/libc/errno/Makefile.in | 224 ++++-- newlib/libc/iconv/Makefile.in | 283 ++++---- newlib/libc/iconv/ccs/Makefile.in | 288 ++++---- newlib/libc/iconv/ccs/binary/Makefile.in | 122 +++- newlib/libc/iconv/ces/Makefile.in | 210 ++++-- newlib/libc/iconv/lib/Makefile.in | 210 ++++-- newlib/libc/locale/Makefile.in | 224 ++++-- newlib/libc/machine/Makefile.in | 299 ++++---- newlib/libc/machine/a29k/Makefile.in | 138 ++-- newlib/libc/machine/a29k/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/a29k/configure | 258 +++++-- newlib/libc/machine/aarch64/Makefile.in | 221 ++++-- newlib/libc/machine/aarch64/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/aarch64/configure | 258 +++++-- newlib/libc/machine/aclocal.m4 | 684 +++++++++++------- newlib/libc/machine/amdgcn/Makefile.in | 218 ++++-- newlib/libc/machine/amdgcn/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/amdgcn/configure | 258 +++++-- newlib/libc/machine/arc/Makefile.in | 221 ++++-- newlib/libc/machine/arc/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/arc/configure | 258 +++++-- newlib/libc/machine/arm/Makefile.in | 221 ++++-- newlib/libc/machine/arm/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/arm/configure | 258 +++++-- newlib/libc/machine/bfin/Makefile.in | 217 ++++-- newlib/libc/machine/bfin/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/bfin/configure | 258 +++++-- newlib/libc/machine/configure | 321 ++++++-- newlib/libc/machine/cr16/Makefile.in | 221 ++++-- newlib/libc/machine/cr16/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/cr16/configure | 258 +++++-- newlib/libc/machine/cris/Makefile.in | 222 ++++-- newlib/libc/machine/cris/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/cris/configure | 258 +++++-- newlib/libc/machine/crx/Makefile.in | 221 ++++-- newlib/libc/machine/crx/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/crx/configure | 258 +++++-- newlib/libc/machine/csky/Makefile.in | 217 ++++-- newlib/libc/machine/csky/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/csky/configure | 258 +++++-- newlib/libc/machine/d10v/Makefile.in | 217 ++++-- newlib/libc/machine/d10v/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/d10v/configure | 258 +++++-- newlib/libc/machine/d30v/Makefile.in | 217 ++++-- newlib/libc/machine/d30v/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/d30v/configure | 258 +++++-- newlib/libc/machine/epiphany/Makefile.in | 217 ++++-- newlib/libc/machine/epiphany/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/epiphany/configure | 258 +++++-- newlib/libc/machine/fr30/Makefile.in | 217 ++++-- newlib/libc/machine/fr30/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/fr30/configure | 258 +++++-- newlib/libc/machine/frv/Makefile.in | 217 ++++-- newlib/libc/machine/frv/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/frv/configure | 258 +++++-- newlib/libc/machine/ft32/Makefile.in | 217 ++++-- newlib/libc/machine/ft32/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/ft32/configure | 258 +++++-- newlib/libc/machine/h8300/Makefile.in | 217 ++++-- newlib/libc/machine/h8300/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/h8300/configure | 258 +++++-- newlib/libc/machine/h8500/Makefile.in | 221 ++++-- newlib/libc/machine/h8500/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/h8500/configure | 258 +++++-- newlib/libc/machine/hppa/Makefile.in | 217 ++++-- newlib/libc/machine/hppa/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/hppa/configure | 258 +++++-- newlib/libc/machine/i386/Makefile.in | 237 ++++-- newlib/libc/machine/i386/aclocal.m4 | 684 +++++++++++------- newlib/libc/machine/i386/configure | 321 ++++++-- newlib/libc/machine/i960/Makefile.in | 138 ++-- newlib/libc/machine/i960/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/i960/configure | 258 +++++-- newlib/libc/machine/iq2000/Makefile.in | 217 ++++-- newlib/libc/machine/iq2000/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/iq2000/configure | 258 +++++-- newlib/libc/machine/lm32/Makefile.in | 217 ++++-- newlib/libc/machine/lm32/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/lm32/configure | 258 +++++-- newlib/libc/machine/m32c/Makefile.in | 217 ++++-- newlib/libc/machine/m32c/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/m32c/configure | 258 +++++-- newlib/libc/machine/m32r/Makefile.in | 217 ++++-- newlib/libc/machine/m32r/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/m32r/configure | 258 +++++-- newlib/libc/machine/m68hc11/Makefile.in | 217 ++++-- newlib/libc/machine/m68hc11/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/m68hc11/configure | 258 +++++-- newlib/libc/machine/m68k/Makefile.in | 221 ++++-- newlib/libc/machine/m68k/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/m68k/configure | 258 +++++-- newlib/libc/machine/m88k/Makefile.in | 217 ++++-- newlib/libc/machine/m88k/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/m88k/configure | 258 +++++-- newlib/libc/machine/mep/Makefile.in | 216 ++++-- newlib/libc/machine/mep/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/mep/configure | 258 +++++-- newlib/libc/machine/microblaze/Makefile.in | 221 ++++-- newlib/libc/machine/microblaze/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/microblaze/configure | 258 +++++-- newlib/libc/machine/mips/Makefile.in | 222 ++++-- newlib/libc/machine/mips/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/mips/configure | 258 +++++-- newlib/libc/machine/mn10200/Makefile.in | 217 ++++-- newlib/libc/machine/mn10200/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/mn10200/configure | 258 +++++-- newlib/libc/machine/mn10300/Makefile.in | 217 ++++-- newlib/libc/machine/mn10300/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/mn10300/configure | 258 +++++-- newlib/libc/machine/moxie/Makefile.in | 217 ++++-- newlib/libc/machine/moxie/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/moxie/configure | 258 +++++-- newlib/libc/machine/msp430/Makefile.in | 221 ++++-- newlib/libc/machine/msp430/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/msp430/configure | 258 +++++-- newlib/libc/machine/mt/Makefile.in | 217 ++++-- newlib/libc/machine/mt/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/mt/configure | 258 +++++-- newlib/libc/machine/nds32/Makefile.in | 221 ++++-- newlib/libc/machine/nds32/aclocal.m4 | 684 +++++++++++------- newlib/libc/machine/nds32/configure | 317 ++++++-- newlib/libc/machine/necv70/Makefile.in | 217 ++++-- newlib/libc/machine/necv70/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/necv70/configure | 258 +++++-- newlib/libc/machine/nios2/Makefile.in | 217 ++++-- newlib/libc/machine/nios2/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/nios2/configure | 258 +++++-- newlib/libc/machine/nvptx/Makefile.in | 218 ++++-- newlib/libc/machine/nvptx/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/nvptx/configure | 258 +++++-- newlib/libc/machine/or1k/Makefile.in | 217 ++++-- newlib/libc/machine/or1k/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/or1k/configure | 258 +++++-- newlib/libc/machine/powerpc/Makefile.in | 221 ++++-- newlib/libc/machine/powerpc/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/powerpc/configure | 258 +++++-- newlib/libc/machine/pru/Makefile.in | 217 ++++-- newlib/libc/machine/pru/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/pru/configure | 258 +++++-- newlib/libc/machine/riscv/Makefile.in | 221 ++++-- newlib/libc/machine/riscv/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/riscv/configure | 258 +++++-- newlib/libc/machine/rl78/Makefile.in | 217 ++++-- newlib/libc/machine/rl78/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/rl78/configure | 258 +++++-- newlib/libc/machine/rx/Makefile.in | 217 ++++-- newlib/libc/machine/rx/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/rx/configure | 258 +++++-- newlib/libc/machine/sh/Makefile.in | 217 ++++-- newlib/libc/machine/sh/aclocal.m4 | 684 +++++++++++------- newlib/libc/machine/sh/configure | 317 ++++++-- newlib/libc/machine/sparc/Makefile.in | 221 ++++-- newlib/libc/machine/sparc/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/sparc/configure | 258 +++++-- newlib/libc/machine/spu/Makefile.in | 221 ++++-- newlib/libc/machine/spu/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/spu/configure | 258 +++++-- newlib/libc/machine/tic4x/Makefile.in | 217 ++++-- newlib/libc/machine/tic4x/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/tic4x/configure | 258 +++++-- newlib/libc/machine/tic6x/Makefile.in | 217 ++++-- newlib/libc/machine/tic6x/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/tic6x/configure | 258 +++++-- newlib/libc/machine/tic80/Makefile.in | 217 ++++-- newlib/libc/machine/tic80/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/tic80/configure | 258 +++++-- newlib/libc/machine/v850/Makefile.in | 217 ++++-- newlib/libc/machine/v850/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/v850/configure | 258 +++++-- newlib/libc/machine/visium/Makefile.in | 221 ++++-- newlib/libc/machine/visium/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/visium/configure | 258 +++++-- newlib/libc/machine/w65/Makefile.in | 221 ++++-- newlib/libc/machine/w65/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/w65/configure | 258 +++++-- newlib/libc/machine/x86_64/Makefile.in | 217 ++++-- newlib/libc/machine/x86_64/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/x86_64/configure | 258 +++++-- newlib/libc/machine/xc16x/Makefile.in | 221 ++++-- newlib/libc/machine/xc16x/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/xc16x/configure | 258 +++++-- newlib/libc/machine/xscale/Makefile.in | 221 ++++-- newlib/libc/machine/xscale/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/xscale/configure | 258 +++++-- newlib/libc/machine/xstormy16/Makefile.in | 217 ++++-- newlib/libc/machine/xstormy16/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/xstormy16/configure | 258 +++++-- newlib/libc/machine/z8k/Makefile.in | 217 ++++-- newlib/libc/machine/z8k/aclocal.m4 | 620 +++++++++------- newlib/libc/machine/z8k/configure | 258 +++++-- newlib/libc/misc/Makefile.in | 224 ++++-- newlib/libc/posix/Makefile.in | 224 ++++-- newlib/libc/reent/Makefile.in | 224 ++++-- newlib/libc/search/Makefile.in | 224 ++++-- newlib/libc/signal/Makefile.in | 224 ++++-- newlib/libc/ssp/Makefile.in | 224 ++++-- newlib/libc/stdio/Makefile.in | 224 ++++-- newlib/libc/stdio64/Makefile.in | 224 ++++-- newlib/libc/stdlib/Makefile.in | 224 ++++-- newlib/libc/string/Makefile.in | 224 ++++-- newlib/libc/sys/Makefile.in | 299 ++++---- newlib/libc/sys/a29khif/Makefile.in | 218 ++++-- newlib/libc/sys/a29khif/aclocal.m4 | 620 +++++++++------- newlib/libc/sys/a29khif/configure | 258 +++++-- newlib/libc/sys/aclocal.m4 | 684 +++++++++++------- newlib/libc/sys/amdgcn/Makefile.in | 218 ++++-- newlib/libc/sys/amdgcn/aclocal.m4 | 620 +++++++++------- newlib/libc/sys/amdgcn/configure | 258 +++++-- newlib/libc/sys/arm/Makefile.in | 218 ++++-- newlib/libc/sys/arm/aclocal.m4 | 620 +++++++++------- newlib/libc/sys/arm/configure | 258 +++++-- newlib/libc/sys/configure | 321 ++++++-- newlib/libc/sys/d10v/Makefile.in | 218 ++++-- newlib/libc/sys/d10v/aclocal.m4 | 620 +++++++++------- newlib/libc/sys/d10v/configure | 258 +++++-- newlib/libc/sys/decstation/Makefile.in | 216 ++++-- newlib/libc/sys/decstation/aclocal.m4 | 620 +++++++++------- newlib/libc/sys/decstation/configure | 258 +++++-- newlib/libc/sys/epiphany/Makefile.in | 218 ++++-- newlib/libc/sys/epiphany/aclocal.m4 | 620 +++++++++------- newlib/libc/sys/epiphany/configure | 258 +++++-- newlib/libc/sys/h8300hms/Makefile.in | 218 ++++-- newlib/libc/sys/h8300hms/aclocal.m4 | 620 +++++++++------- newlib/libc/sys/h8300hms/configure | 258 +++++-- newlib/libc/sys/h8500hms/Makefile.in | 215 ++++-- newlib/libc/sys/h8500hms/aclocal.m4 | 620 +++++++++------- newlib/libc/sys/h8500hms/configure | 258 +++++-- newlib/libc/sys/linux/Makefile.in | 314 ++++---- newlib/libc/sys/linux/aclocal.m4 | 684 +++++++++++------- newlib/libc/sys/linux/argp/Makefile.in | 224 ++++-- newlib/libc/sys/linux/cmath/Makefile.in | 224 ++++-- newlib/libc/sys/linux/configure | 321 ++++++-- newlib/libc/sys/linux/dl/Makefile.in | 224 ++++-- newlib/libc/sys/linux/iconv/Makefile.in | 224 ++++-- newlib/libc/sys/linux/intl/Makefile.in | 224 ++++-- .../libc/sys/linux/linuxthreads/Makefile.in | 339 +++++---- newlib/libc/sys/linux/linuxthreads/aclocal.m4 | 684 +++++++++++------- newlib/libc/sys/linux/linuxthreads/configure | 321 ++++++-- .../linux/linuxthreads/machine/Makefile.in | 278 +++---- .../sys/linux/linuxthreads/machine/aclocal.m4 | 684 +++++++++++------- .../sys/linux/linuxthreads/machine/configure | 321 ++++++-- .../linuxthreads/machine/i386/Makefile.in | 242 ++++--- .../linuxthreads/machine/i386/aclocal.m4 | 684 +++++++++++------- .../linux/linuxthreads/machine/i386/configure | 321 ++++++-- newlib/libc/sys/linux/machine/Makefile.in | 278 +++---- newlib/libc/sys/linux/machine/aclocal.m4 | 684 +++++++++++------- newlib/libc/sys/linux/machine/configure | 321 ++++++-- .../libc/sys/linux/machine/i386/Makefile.in | 224 ++++-- newlib/libc/sys/linux/machine/i386/aclocal.m4 | 684 +++++++++++------- newlib/libc/sys/linux/machine/i386/configure | 321 ++++++-- newlib/libc/sys/linux/net/Makefile.in | 220 ++++-- newlib/libc/sys/m88kbug/Makefile.in | 215 ++++-- newlib/libc/sys/m88kbug/aclocal.m4 | 620 +++++++++------- newlib/libc/sys/m88kbug/configure | 258 +++++-- newlib/libc/sys/mmixware/Makefile.in | 218 ++++-- newlib/libc/sys/mmixware/aclocal.m4 | 620 +++++++++------- newlib/libc/sys/mmixware/configure | 258 +++++-- newlib/libc/sys/netware/Makefile.in | 216 ++++-- newlib/libc/sys/netware/aclocal.m4 | 620 +++++++++------- newlib/libc/sys/netware/configure | 258 +++++-- newlib/libc/sys/or1k/Makefile.in | 221 ++++-- newlib/libc/sys/or1k/aclocal.m4 | 620 +++++++++------- newlib/libc/sys/or1k/configure | 258 +++++-- newlib/libc/sys/phoenix/Makefile.in | 296 ++++---- newlib/libc/sys/phoenix/aclocal.m4 | 620 +++++++++------- newlib/libc/sys/phoenix/configure | 258 +++++-- newlib/libc/sys/phoenix/machine/Makefile.in | 294 ++++---- newlib/libc/sys/phoenix/machine/aclocal.m4 | 620 +++++++++------- .../libc/sys/phoenix/machine/arm/Makefile.in | 214 ++++-- .../libc/sys/phoenix/machine/arm/aclocal.m4 | 620 +++++++++------- newlib/libc/sys/phoenix/machine/arm/configure | 258 +++++-- newlib/libc/sys/phoenix/machine/configure | 258 +++++-- newlib/libc/sys/rdos/Makefile.in | 218 ++++-- newlib/libc/sys/rdos/aclocal.m4 | 620 +++++++++------- newlib/libc/sys/rdos/configure | 258 +++++-- newlib/libc/sys/rtems/Makefile.in | 219 ++++-- newlib/libc/sys/rtems/aclocal.m4 | 620 +++++++++------- newlib/libc/sys/rtems/configure | 258 +++++-- newlib/libc/sys/sh/Makefile.in | 218 ++++-- newlib/libc/sys/sh/aclocal.m4 | 620 +++++++++------- newlib/libc/sys/sh/configure | 258 +++++-- newlib/libc/sys/sparc64/Makefile.in | 219 ++++-- newlib/libc/sys/sparc64/aclocal.m4 | 620 +++++++++------- newlib/libc/sys/sparc64/configure | 258 +++++-- newlib/libc/sys/sun4/Makefile.in | 215 ++++-- newlib/libc/sys/sun4/aclocal.m4 | 620 +++++++++------- newlib/libc/sys/sun4/configure | 258 +++++-- newlib/libc/sys/sysmec/Makefile.in | 218 ++++-- newlib/libc/sys/sysmec/aclocal.m4 | 620 +++++++++------- newlib/libc/sys/sysmec/configure | 258 +++++-- newlib/libc/sys/sysnec810/Makefile.in | 218 ++++-- newlib/libc/sys/sysnec810/aclocal.m4 | 620 +++++++++------- newlib/libc/sys/sysnec810/configure | 258 +++++-- newlib/libc/sys/sysnecv850/Makefile.in | 218 ++++-- newlib/libc/sys/sysnecv850/aclocal.m4 | 620 +++++++++------- newlib/libc/sys/sysnecv850/configure | 258 +++++-- newlib/libc/sys/sysvi386/Makefile.in | 218 ++++-- newlib/libc/sys/sysvi386/aclocal.m4 | 620 +++++++++------- newlib/libc/sys/sysvi386/configure | 258 +++++-- newlib/libc/sys/sysvnecv70/Makefile.in | 218 ++++-- newlib/libc/sys/sysvnecv70/aclocal.m4 | 620 +++++++++------- newlib/libc/sys/sysvnecv70/configure | 258 +++++-- newlib/libc/sys/tic80/Makefile.in | 217 ++++-- newlib/libc/sys/tic80/aclocal.m4 | 620 +++++++++------- newlib/libc/sys/tic80/configure | 258 +++++-- newlib/libc/sys/tirtos/Makefile.in | 218 ++++-- newlib/libc/sys/tirtos/aclocal.m4 | 620 +++++++++------- newlib/libc/sys/tirtos/configure | 258 +++++-- newlib/libc/sys/w65/Makefile.in | 215 ++++-- newlib/libc/sys/w65/aclocal.m4 | 620 +++++++++------- newlib/libc/sys/w65/configure | 258 +++++-- newlib/libc/sys/z8ksim/Makefile.in | 215 ++++-- newlib/libc/sys/z8ksim/aclocal.m4 | 620 +++++++++------- newlib/libc/sys/z8ksim/configure | 258 +++++-- newlib/libc/syscalls/Makefile.in | 224 ++++-- newlib/libc/time/Makefile.in | 224 ++++-- newlib/libc/unix/Makefile.in | 224 ++++-- newlib/libc/xdr/Makefile.in | 224 ++++-- newlib/libm/Makefile.in | 374 ++++++---- newlib/libm/aclocal.m4 | 684 +++++++++++------- newlib/libm/common/Makefile.in | 224 ++++-- newlib/libm/complex/Makefile.in | 224 ++++-- newlib/libm/configure | 321 ++++++-- newlib/libm/fenv/Makefile.in | 224 ++++-- newlib/libm/machine/Makefile.in | 299 ++++---- newlib/libm/machine/aarch64/Makefile.in | 220 ++++-- newlib/libm/machine/aarch64/aclocal.m4 | 620 +++++++++------- newlib/libm/machine/aarch64/configure | 258 +++++-- newlib/libm/machine/aclocal.m4 | 684 +++++++++++------- newlib/libm/machine/arm/Makefile.in | 220 ++++-- newlib/libm/machine/arm/aclocal.m4 | 620 +++++++++------- newlib/libm/machine/arm/configure | 258 +++++-- newlib/libm/machine/configure | 321 ++++++-- newlib/libm/machine/i386/Makefile.in | 241 +++--- newlib/libm/machine/i386/aclocal.m4 | 684 +++++++++++------- newlib/libm/machine/i386/configure | 321 ++++++-- newlib/libm/machine/mips/Makefile.in | 220 ++++-- newlib/libm/machine/mips/aclocal.m4 | 620 +++++++++------- newlib/libm/machine/mips/configure | 258 +++++-- newlib/libm/machine/nds32/Makefile.in | 219 ++++-- newlib/libm/machine/nds32/aclocal.m4 | 684 +++++++++++------- newlib/libm/machine/nds32/configure | 317 ++++++-- newlib/libm/machine/powerpc/Makefile.in | 220 ++++-- newlib/libm/machine/powerpc/aclocal.m4 | 620 +++++++++------- newlib/libm/machine/powerpc/configure | 258 +++++-- newlib/libm/machine/pru/Makefile.in | 220 ++++-- newlib/libm/machine/pru/aclocal.m4 | 620 +++++++++------- newlib/libm/machine/pru/configure | 258 +++++-- newlib/libm/machine/riscv/Makefile.in | 220 ++++-- newlib/libm/machine/riscv/aclocal.m4 | 620 +++++++++------- newlib/libm/machine/riscv/configure | 258 +++++-- newlib/libm/machine/sparc/Makefile.in | 220 ++++-- newlib/libm/machine/sparc/aclocal.m4 | 620 +++++++++------- newlib/libm/machine/sparc/configure | 258 +++++-- newlib/libm/machine/spu/Makefile.in | 220 ++++-- newlib/libm/machine/spu/aclocal.m4 | 620 +++++++++------- newlib/libm/machine/spu/configure | 258 +++++-- newlib/libm/machine/x86_64/Makefile.in | 238 ++++-- newlib/libm/machine/x86_64/aclocal.m4 | 684 +++++++++++------- newlib/libm/machine/x86_64/configure | 321 ++++++-- newlib/libm/math/Makefile.in | 224 ++++-- newlib/libm/mathfp/Makefile.in | 224 ++++-- 375 files changed, 83297 insertions(+), 51688 deletions(-) diff --git a/newlib/README b/newlib/README index f60b294ffe6f..c025cb38d0c4 100644 --- a/newlib/README +++ b/newlib/README @@ -607,8 +607,8 @@ After creating a new configure.ac and Makefile.am file,= you would issue: from newlib/libc/machine/XXXX =20 It is strongly advised that you use an adequate version of autotools. -For this latest release, the following were used: autoconf 2.69, aclocal 1= =2E13.4, and=20 -automake 1.13.4. +For this latest release, the following were used: autoconf 2.69, aclocal 1= =2E15.1, +and automake 1.15.1. =20 Reporting Bugs =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D diff --git a/newlib/acinclude.m4 b/newlib/acinclude.m4 index 693bac62578f..912d4a3afc9b 100644 --- a/newlib/acinclude.m4 +++ b/newlib/acinclude.m4 @@ -120,7 +120,7 @@ AC_SUBST(newlib_basedir) =20 AC_CANONICAL_HOST =20 -AM_INIT_AUTOMAKE([foreign no-installinfo no-dependencies no-dist no-define= 1.11.6]) +AM_INIT_AUTOMAKE([foreign no-installinfo no-dependencies no-dist no-define= 1.15.1]) AM_MAINTAINER_MODE() AM_SILENT_RULES(yes) =20 --ySC0KhfPSntW7mR+ Content-Type: application/x-xz Content-Disposition: attachment; filename="0001-newlib-update-to-automake-1.15.patch.xz" Content-Transfer-Encoding: base64 /Td6WFoAAATm1rRGAgAhARwAAAAQz1jM///kgxtdACMcieb23/d7tkEyitymYEMsREGuTjNz foqSuB7tIvgFqqg0wMerccEbqYP8qyRNjuy3nbNQLM8f4PdG2rjK3a3wRbKUUc3I5NPvw6BF GqDjR9m9STRpWcBneXoABf6ZSpYuMHDEt5kILF8T3mno/ulwd8ZymSWsVKp4AB6NdxTNKyX+ 4w39b0r3hQdN/4wL+t9bAx7UHUrn9vsHJajGy4Qjzyu4a//S7OPyQv4AqwrW9h6kRjGldvXK hmk+Ag6toak3SFDNrIuj2p45uI+Vr7nV5IeKdLQpFtp0BMq4aDqE7Vv3Gvper+X0Ym662c9O hHWXGiVNISadzpXaSiWlLWuW20Sa6kVOacXo/8NYiarOlsiwjEbTcWcLwNEnRTEUzylrpyS8 vcebPnu1RGhNFcqLvNgVJj4Mu4QVcPBaOxDVp/ZQmqArzLJSttMAA3pfsOi/C75IyetE1tuA qzadT+7CH0zafpdRV288Dslxw3kVDZRrMYv1x1DEb8X05FZ0qMij+PMWtYOhHZ2WxSE9EbkP 8XT5MEL1oXu7P6JC9TJtUKGMmwR09Yyh/E3VuV9msKIRRSZot4+fijw97tRcRIIvuw+RP+IR m6xhDkpjz7dPW76utsWzmf+QgXESTxWkzTRDQJwQS16kCTIwYwX2Gt/cA9TxOStcadlRi1qJ IFkqXS9THrJMbwEUyJInQwRoq+4JfdzY5PppT3tliMm+tS00BdxJzKgy02wsOhc+0Ji88kCY gVzyv3XS6g/vKfBQqXblyjnXk2cmA4NN4qpNFnL5EbWLBBFGA+MmAH56OmOGeaf8xFNGDWcR ozGwrBCiBNKlP67aHbyoeOrg6rlV2uc8XBDt3MOwxdRQHWr7eaPH5EvvCOCEcsnaskSfK0u7 coTEeqgUmOQ9egj05WrvSOTBruGFticrMWXmqr5WVI1sFm6MTVzlePvFoUaNrHH8Avj+WPHc TcsZvc3P4OQ7L0wo20bVyUJVF8GZU0kpYl/sn3xaHl0jTjZuMfBTXTj/9ozpu6ee1Bnu9p1a X2fJWCOyG0qZOthF3yQuK+fiLPBc6i2DXl6POAmW/pKRj/Mlya0RZnp8GMmXlnvrr4WTtD+U 1U69hAFIFYVlZE0AWOeYqPlRda8OTxE3wne9ArpdRKo8JIwLbEHXbT30PWv8AMowzOO0vGaE stpdmT2Zt2IKnU4tTXSX8xlnuaJQ6Me3+Q/wAY0mpZ0EXwmIEW5KaCvnwVkesI137/GCPz9z FZyNVi1qVs9oj5X0WtswP6JE1YKS90mEDvRB0XFLzuGs4BC15oTOck+TROvd/Cc01ElcwBrI cFhwwUsUJK1gX3QOgEDx/Dgye4BR4nHTfwmFGTtdsurxtHaSExyG/101PiCUiitxrVYgvXls DgcgBjt/stTq0Cyx8CArbu3tnnlrpsYTZ0DlZwVQjEO7gFNEc13VbpePJDCaXpswoeY6lETF SdZesgGIdpEnICF5oVSMELjdoO8wvNmHQIg83KZiL5HVwi1cOthonJNGjA5rNEvJOsgaCMj3 zoaXVrKqjmoJZVNrVYyA7eWJV50PHfLdZ93MeFS9VqrssQW/f2cFu3U5cwaYJSFDxlzvhIrj L7S7NT5eq7M36DvzG2CEaGCzFZYoHrGxtIRPHfwX4GonicXs1HpZW3U+KofsXWP8J/m8KxEY ZKW82CooC9cSFaG9TgCiOuND9KKQRUbw8Qp+9dRJk2KGf1Vic+aaYsBqmtx3uAw5bdwqYoIS yMjAPzAqan7zdMxtlfgcpQytJdIrATcQs1mhHLMz8tpAteNMT9a7nvuPKNhORfvAIXVHzEWM eQQtt17G433xtS2H/4SqGG6OzX/TxX/KK68q7BUPaBzIMOIFbkuAPlFOyNAH02toDlyZ6kvP XzErfhvDWeBr4IMbdoq6n3uY0EuSjno+t/JXtUelSH1/VUYxJFk0RytGc7c6s64T13X6FiEo a+BIShdQFvIumguImBJ4F+uHNu8X1OrQfpUesgshfdph9SBSp3/WrTKDSr0yMyJ32d6pb7uH AtRrV10Rh206+26w/9Rpqc4T0R1EO3xuOD4WG5eocUKKjssRQ9DFOb7l4eirVoGp8vtP1/xC YfXEs1/IYi+BobhaBPRvaZ396/UXnvHSDhMXRZb7McVFtBmo/OQ+SWL+5NkIbSSjkENz4IU+ GFvV52PNZ1FSubSMBwRy+omGfz4S8PUlpGMv+GRovnmLHbir3CNAISvGSxP08uIlcHdSsU1s IZKSnIA9eR9+VGV8UEqBqHidoChsv2Xuv9tz3hO33qISNnfj7xu4NqZYwoJGL9Xy20j29QhZ 8fmyST0UcUEydpbsizvb4pBFDQc+jGmEdN/ikPsFw/NubTzOeFZ/zGIJZHV+9mA7AXYy32tM O4xM6398oQ/YqMqYCAw2jhG77gChsgbIrwWjEntfQEDSfJF9et+8agXx/I8hwlIesdZ1FfKO D5yGZBTdlr4ycG10hHvGhgpHcZ/NAf+4GO1C3vhP/aw/vqbK4lYs75khe7EkN2VPLEABH95c 9iTOl0f85lpdKtlPY0WaMIWedx+rhHNNTTIiNaL0CcV4Z85LelU2k3DDoNhjOnF3tl1Qqvuf JpLDQHU0uiMbac3DBvkB24PGNPIn6MeT5LwB0pDEhT5r+UdWXduBkgLBt3RNnk353NWjGMN+ 30VBaI3+1aq76Skil5yJHm9QyNELEDtNSReaU2h7u3/zfiZKOHL1Hb0xjKwTkXQ9AmJjgYR6 7u0YELJxtK/r9IhfgteFhmYraqHyjlKOIWtQHUStqcdXBiOA/HU3DJMtaaOzLi39zhmKFkIP XzUZMRQ8duTK1Uy8XWqtnOn/mzWz+t0SjPAkc4q52aDNKJe28cjHekdB2FlK9eo7OtLq0XZm G9JADADDQjGebN4oEsbFuUjZsBhyMAVoL9c1WdwnPdqOCpuOkQdBzUAVkwwcg4TIJze3yntU SaYqYmqhu9ZW9n04sRRWM0YcMo56Dlv4XTjzE/YT/IEbtfcdvAGQEcwDUKblLeYwtWTpZcRP 56DyynbP1offLH6GQYLDvqC1QX+kFJZXU4J0QgjfldoaQ6MIXAaQM2ZmebTsOVgyYQD6ysFT IjCiZtLpDvaAsr/d3wfdLfr+rguZEq0nV7F8x40D8wvjWFsfyCGhZNEMQPPxASWCcEnAY3tw eOQG2d3VQkSEL4+YVLhWYFv58C5JtOYpU2NvyhsMbqbRZyVWYl/UyGByVVFAU+DZE0x3jGv3 +vMcEmLfAhZqrguFflZr+1RcVdmK6vWEFEcarb96T6KKyYOcqcrQ5sN4O8HX4H6Hx0gCvFpG yuLwv7afkAFmuqXCSn4VqZaV/qHDq8CT98JopyPIuXWHqZzfCWHbU2GUOBW0BsU8A0x1wLQp UY+lyJPQ+M03Pwbj0FVhIIgpxhzO/hLaxWtrMc612d+Y/+aUBKk4Z7fkds91GSl+iWygoWoR B8dH/kezlBxBSYSowLxnfFXE+5wrCbdaLcv3NaapLTPnj8W4d6OZqiG1UJ0IjofvJ8z7WLpu +EjFav0YYSY2wv0b60aD3F3qBZBWz+YJnLbI3+o8pLlGlUb7dEBTl6Mr6+Ha073HJg3C61Ep h+L8DcXEEEF1g15BFAy8UfpW+nWfCLrSepgsPH7dIi71/4z6SpD/yC8EHfKG4EcWMBE712CO 44TWDYmPZ1Q/0w1tK/pUNUc6keiquu7fa3dqat72tnx2by3CKCJtS2DjU0Ubsz5DTzpbFPXj 1F4BtineD5XsWUlR8r1RF8RqR1KaOnlooMYYLdeqXOnfqIVZrfXNWwHoA+63zlvpCKNjt9Ly wFxwRspQmYu2qtI5PyXpFnsKI+cTZXgFiHV5/v9sToUuDnHXxzDCvs0fICMAoqswMb1aFiFi anvXrjvXhgMNUij+V9yWK8+pLKz5lN11C7t35WNP4OLXaPnqnotDERb8YZI+3VQwHUp4EnBL LTi8rNTqmnMYLlhQ2bydIoRgBDhk6Xyl/UauAxS2YE/mkkXdB/eUh3NcSJ3uMuVtskhzy1Kk 3UsxxlErrNTnfvhc6pIkPNiTY/LNh6cDyUXh79JDT3X+Q/J/yMOLtAM0up8B8UnI2qvenGNq yW7s1MYBCIgEqoh9xhjEWTBUBbczq3zkGyg5+QNA0NJmOqQuqyZub/EHj9qVf+ND+R0bjwij O8tHn4+/pcEmfAhql9Rk4oaTKxWTYExCTtaYHL4f1aaYmt3AeCKat6W49zyPIOUqElxA+eMS A933CxqbZkmIlFMMGPcx3zuz7niIWyWFD1fHCOpQj3bT6tCK+B2RGlA5zjlmqXtPFNaht/yZ cIENU23Ba5xUena5rOw4l3XSm491qSL9GlYOcR1dyCeVU7r+NyvpyPf+jm5Un9k4YY1ZJ4Ih 2YcRuP2EK/8uWL9gMIA7GwVlRaNi+SvHqhX3q6ooykVWS70exu/RivjuXUP35/J6Lb1o6OtK w2VJSaO26flt7afh0aDaKtceEhQ4T4mYkj82z56gcha0tuvbWxS0Y4Po5hkU+vQ4Wdijs525 l1k8pNJnwKwV1uuyumIp5Ezc62CDEdHh81d/1yDZXU0IZSMBD+WTTKOfApQEwJGUfIMNttTK D9bncgI7/OBTtmMVU6efifUEqy7z0PFY17Zs0bWXl2mJIg0UJ2C8LYodeFM//d4bxLe5yfwK fXtV88I5Ibyb0G3qGiZ5RSJyY+Yrc7dnNA453/ugrtOIXlvcz2MQm3aZzb/ZMqC9WXfPJBY5 GMUPV2OO6QTSODeu5VZUVcMzBcrdrujfIvYX8PCXTriifeBDrugi29nEB77lswpDj1TTvxY3 cZnr2x22HloVzb9TqtyMu1OhfZlS+XcM0vfGMfY0ucynX4OKVhAamg2ttBhFjmWzsidM1Zam hiv5uvTk4ZZFVG6K7pvqOpPnDQ0eCIbDJhSP9XpUIMlYSiEMoMM5sgg7EKOGhfRh0RolX0H4 g0JCYqW02lxYz1raEdogFKmwbtyrbUbhiHzBZ8SByc27aCs0QniOBvIAqXUz1kpI+YmqeMgL pC++3VANlRcLk3RBtJpweB+i0IKOGbIVXi42+kN3zsM1bm59fPG21OdkS6gvvPRhfri3G73x 8YtT8ljXl1kgvK3KVfw6UaDydMb6fpAey3nyccaGCg7aSTvaNTITdCIXIwbWeKSKEwlAMQXm +G+Z146ZcxZaf+T4x+gpOkHMnXzSOBcANW4Kf74+gb3wSJXQWs8BbpuG3H3+eXrFAJAx8+dP 2nlRYJpz+s5f+8xrNNsYln5FeNz/Y+tM116k0aa+gIuvYpkCdl9ar19QpXLN7Exuas8OhEzY QovEptXdkrzoVXFoT2s6KHfD+x4bMmvnkpWvGauCYCGfVZZ+x4/CpWVG3ww8gJKL7x9e8hxG tjDYuT7Jax6ir7LfiCzsmb6TWq6+chcSNpWz+el1acRIptv8br7JU8DDAFkkp6stlyFu73XS hr4QgHz7LLULhmb+eV6mnxZ1MFbIxRYIboYjtTROzIk6KdliDpkkFTsQPa1lrgoeF24Rxccm G5f4a8AAud9+6CXEZY3gNCqoto/NErA7y/8lNsIwebbELK3betlu97a5vS1XxeHrCf+V9frv pWECXkPw8HaD+rmoRsXrCvzHejDaagMkRB7uDipHBNhx6Zbp7lktGKcODrEoYpKv44HGkopm njR7C7avGmzc9G7GE3TDxxG27xcbrWPvzyZNsGsNtH0pDd0/6NUK7XCRqCnJrHevSv7ApmBO NG1+zlYPtnTg/uT2ZjvNAWl7yQlycNGl4nsXaH8Z7AAxR1ZAvR9WNmKDUS1CQlXyXNt8ITGR Hmr4Y32OrrmzxOdmF7plSVt9PUgyGLW5h+RfaRnA57D4WMlKcheHbCseF2y5O/M3keIj6w9v OGUcZwLntQhu7/9r4q/mxBkZCN54W0DYs0a97lZ6zMryzSCai792o7y6PzCxuHMk98K8OCaP 4S9bWBFHXBEb0Etbhiv2joamMStfEo8WEn2+Z0R5b0TXsgKJg/LpUiECSITs3fJyQaxjWM5U 9sXtPUpEd28AzK41CPjcqBTGCcOAev4cSmV0DCTCaH4lhDZW5if/LpSxrN7Z5cqSe7KxYM0n QMrtI5kldHPuCuVP/Q/zsOaeeH55979b2W5orB7yEIaGe2sK1IFTvi3mSoBYjbRzTr2C/pJp lpQqfJIW2L1Ea5UkBCSHsJam6tC4gvf4ZHfWlO4P454qsDN0K+sggn3wlyUBWF2oIBLXXAPN 7E4mSgJHzenw6bEw7m/QGWq8VdnbowOXOpgGP2RVSP12sl0n0M9b6Sva3aCihhMN8Trx3QrJ 6xxQN1nbyxBatM8AFe1m/VA8XtjRx9zy30OdKKaTx+ZkOF622/a5thfZMdbPZJedX7somLE3 sL0dJaHf1ndKckPPSosR8gCpjThcoWe2EsBASI3uSxcReieRr0MVf067qL/D5pF3CF6xCT/0 OyZkDOrW7i7IqJetdcNYNKFsqMR31VRuWKQzQ2uuSM7314XSj8GG7B5qMG+uQWHRRZwpkxyt PDxTgHCzRfl4Np6CJkOCp/dOq40IJv0vX591e7W7Q0PXxGpnygrhwT4xyzRkjoW4c+SGPfC3 k8Gd9l1fJ0Bz51J0JU1ygJlBUyTcbbktx8wMM6LTI+RydaMFmcHi1/nfah2VC28S8YNndVpS JFyQLtuKvliR9MlrTgsGIfgPufRs0V3xvC4o5tX/ZhJ56L29VY16i3xTuacixwtMwa5GulhW 8XBfnLuBJ+yldvjMjYf8zjE71Lsg/qY900+zrN+XQ2O1DX9lyQxMZ3m6QeavAMBvZi3wP9Hq vsqb/SY7ZjfsTgGRRKxrrnbDVUoqF9Sm4cmCbyVRYzppjOfig4GGMyt9keNXduXeHqscjd+0 te/HP4umGHuaur0hOri0VPGCrc0mYl6+iZPbhfid9112ZfDtbjiVkPR14PJZ5h2wMd5z9u70 Ma8erMHANezs5Iq6uwlWdb86Dd6aMgcguBj0MvHCTYiQk0eWOW0Tax99Ml0wNtypfR19Wm4C BpOjWbGSWaSgOb0XfKlffh125KUSrB1wjzMbRJ+HmKbp8RlUU9vqBHJZze8SlKVHxTO4nSAU MjARWTpeYEboss/Vf4cvb/Q+lW5R66ueoLU4qnzUmVEPdqi/U5L60wVl/knqwya5ba1T3jxk l53BRMwdY2QROAUip4q0ob7nBDjX7U0hHkflnl8ZmkPiuvmgvsTmKI+GPg0XfPKD6rjJAUt1 Jp3GN9WqlkBB60V/hyqOgJsrMgYbVUITzjfVJwVPO+rd82iwhKPqLYOZ/Qc+cZIMZDxmuUj1 XhhGroZdS6LJofYfb3IIoEdZlyRwEWajIUQ2ZJp5ukMvBo1fGQ45K74ik95SqmE1s54aBQJj +NfWdT0xja3WIeNxo0gI0m6GlqpTYxImYUk7Qc1Y+/laTb9p1l8lJDaeAneP8njPvmwk/BXd cFtpTTmlyi8FmqUkqWzN/PQhdjrmy4xy3tu7oqnijyEyoP7192UU3PzNlkp4sorwy8vvw/hE j06HL8PWM3dbEiTzICS9vtHgGJX7i5avBFoRUwhCRXZzdlaAkpVplAU1WTc9N+SnhO+gALrf U9msLDJsdozC3LBqgt4DkrYexIXeL5+TBQDRWpWGD4h7nrB46N0TpSBJ4g4hw3vlhq8FSz6k PLxnkkuZL3cVPvt+TNokid2fC0mGE+FLmg3OuE/PSsT2VDnoK+oYAF5Yg3Gf2fces+z6Q0Vx UvG6o7bpRQgsc98/HOn9bAcxbwviSTpO0wj4SnufbnPlFwXz0g1cKjvYCddGdvwj9xxJAzaq lbuKwHNsslGfI1JVA9Bab1FVGti4YoUtrbL9BRxqZuDsU7r7siySKlppYuTv+Noz1WgD6NQW DgbFwKF4bHQucBad/rVxHQqZZbTW1g3jkY188F8Yz/NYR626rFz6SSd99nTbtH84RTCee+7v hz8eM7OmOVtFnouDXRMw2l+cPz+XjQq/keI274p6B6yzxAlmKJG5JNCYVcWT2zfb7XFZF9kL JkmbI6kQrdC/fvV2YEMNV07sdNbsg9eRjYJP0yPxz+LRzsDlbxWNRv4DD7IRFb0khGV9x4Q8 rjZtDRtTBIkAfQKJp9jtr3YBRANTUS50429iXJlnvdbfRRj9jzF/RKpxX289Xc/pp1c17zVZ nGab/HViLYe76vu+eECsMsh8zrU9fKhcYyu/3rdC6cSfHdWdmcaZWz9kjeXbIQ/VmoKBJBQE ptwU+0+EZgg8uvf4FSeZqEZ94KWsel9H8PMX0kBaYehoZk9nPNXEZ/qcmNWIQsAz2NX9gRpk GRcsZoeHcvItlmNjVIrekba63g+uo17nZwTLwAGrykGzj83Yqhl8TurygUm+fEU1C4lrJDGQ BVt6EsPkLN+OUoH4V0i4WsmA4EhGg9bs/EkPonJrm/yKU+kigvNtFP895Rh77YC2aqDt5Pu6 A5rlXTMIaVjsNR+jLsbQCJZ2j9RFbCeocGhvj3Yw9/sdVEUxFEZId7Ic/NVWvekNee4RluTO M4JljxXanUFYfxRkRP8IqGAajbpAFlWTC3nUKSK96UKwaTaXpRh0j12papTnYXiGPKupKJUm lc8l+ORbfAOvbSnBE+Jcf+Eaexxfnf7NJ0ha77fRnjH0rkuXAOwHdm+m1jwQlDiLYuW3M2wE S82qU/npyrGPNAv9+h0ZKsLxHa1yxwWl1OtbdDAR6fiEnrpVhGiiq+0WPf74qSb0ciA/3TL8 ftrUpuhyhfibj5QjyEZkg2D5AdDTUY9jvfUoKTX71YmjOiwzKMhkgUB1FEhBrgZk1OZLOmtl mA/CGUQP/3OmQc9Di0ApiXgTLlKBQoMWxAfFj0gPO5gFmYT+/TliJpRCrX0w0zcLANdTJm2Z 3IToJGZkjGiPrA3dwsoXYdK1sRJmMpQ988wCjpQdRW7zns7RXFsmUetpdK1lsGdoga+zNEPT eYhwARJZwZSC+idD7mfLLeQ5sTkSBoHWXhv1G3EByMnD4CGmXbEuRegVK4wTMfAy1doL5Ow8 pjrcPehj2FGXNI4O0VudMy9Jq4iLXSCYJ8LLkwxoO5YQOFFzwHAeN2FRY8oWOswCEDVOqMda 3Bl1pNrRS2uAEue35iANpmu9VqcKdHwc7nEYC7WsjtHCDAfPxr3y/CjTBDvOVVwW+BQF7/Li 6FhT+C6ID80/VObeCt+6+h6Ac2x9dF8bjxmp2Pi94YCH/SsGMcuF2uj4o3GtJaUs0ihvAH7U VG96rhAFD3eNuWmYLOSO3NKmEkAmBzkqNUp/pQjMi77RhQXfIDiCX9TPd0FdLcQQLcgDp4KY GoYZEs9bbgPdNu1xwpQN3cd0mDDWc4nZtGAb6eOF91NmRSY54cV7x6oiD8H+BQExslHC1/5C lBYPHF9zKR0XWWv9GihSCNqdyREX60Ny3A3mAFUi2qZymT5IzmlSGpJ2GbhhVz/y4WbR+JEa ZWcx4mY/B8xOu+bH3FxWjrfZXr9U6lqO8fze0pYma5pP5L9uX5nIbpoZ3875TvK18WxI7hVU ZAZfmpC0b0qBDoVkNkW5Qrkvo9115o8RYuqsOnhmZHuiSb1sKIAXJqrcuIQTmJ7k9DqLLKlW 7cnjfr4iH3sTOA7ARvy7rdWUCoSDyMYho5/NhovQDHtOfLklEbfcBsYuaXo60aHC6kfVkAdu JyMbc0vyl7lG7Yj1leXbZSTEFYr2TjUyrwO3yrO2/v9iIXuBzN5UbDXMB18h8NwccJbRfo2e m3jZeBbsS3B5FFZ4TOvvy0VOwIAU2HFHcfO9vEb1tT9TToRNzmeHpBDH+XDTKk/rkJW4v8rK VBTV7qOLZyLeFUewRaHBa4L6ZBalppjBPSt+fprikYQlhhfisr5Q79uUefX4Zn2sXMxELZrP 01LByZBfFSWJ89rxWj837aArxzfThHlxNqUvwv2Cw53IL9z07QcJeZ8qewYEK9MG8rYIU5B0 wYl7SbYb8h4kUvA+KZ7SKdVsnW65cfWnK6LeXdz4IhMmE6MQG/hAjrBOP2McEhc6iY5U0Qki eSmU8oayXsjKVVrqKRIbjjTuPXWykoFk+bL1UGLjTYeszPThUHDhZJpPzTRuVF+T2X+vX9G0 ceFFvxYxV99ryUXzUT1kCmZMyMpkNiS/DiqP2SGyL7CR1+tvAYc3/lbsFph+W8dwbuGN5z+b os5bGxtLA8iKgfknoqUTuLIcf/eSw/hwxb7Gj5bmCONe62ZIzQcd1F0iAlXJeimAlO5KRFpL Ysiz2kxQTbTs77paDmsa9X16SVUc7hCiJD3h+2gXNV5JlEdSv3K+YBldaNXp+koDd9keNoKc 3TDTbwPAcVmMX6NP7CvsQSqqvQaL9M7YCR1aSmMoI7t9YmtdSxMNnsQGsnOqE/8HnsnVCQyJ RuLYPMqp7TkEYu8agaUT7XHHUK8BfNxioQYn5SZpTRvd0R7wxIJp3jAmDtlXzU/TkJEgt6DT XrqHjoHYPlYXLQqrmBIadI4LhaqhDiRGIFYoBYakC6diKGxiwPowXQVS+wSvsodbVAgb410q PZ3qVLaNWgDHRzgohjs2DWg3F/USfeCaWEP9cglw7s3/eLYsLT/zSYe2ZXOonSVTLqnYpDby jECdnmZyLlwuDSmiYWWQVmkX+Ws5yFdsDqrWU1p8vXD/FweKgtYOu803wMwhZKVsKyXwXguU ak0JfiV8dqO6WeT4z7n/w61xErOB1CoWAkIqw7WWt264cBlgUk7mGYhbCzcVvU3iyzxyWVAM zxrApVs+UQdcmaJSY+L1LWTJKGlJKPDT2LyZBy75SkYlYLt+LSB+Nj2o5bFlylVGw48RMPYX X1o6jzt0P+cbf3gypXvoUrLSMz6vkX8gAiskEo9lNor5IH5EuxgeHqkNOBOR/Lpky57PfjW2 Whmyb+pFJEV+29RYmQKq4VhxjRrmVLy8Ap/JbDwJJCDbiqJdSWiDVfkucXCO90YFkSSBPdW1 g0YUCICXzD21zmvgOx97jUkQb4bIF/aQZwXwWe9vLpNUbJPxkMuwN5GvL04RUr3Sdd+UBD3j kk53iBLVFBw0Nc/LQmqgqdtsH8erCYtMv+nTHNeKHSSG1BMBXOAcCpq4P3bxKz56Ih1HlxaX qPVPtKj9KxkUCOyI0hf7Z6W22aoHlwSMp7Kmyh8UGmZZDU+ypKcccOCxtWsuOEQ3Yz/vQAbB /Ntnw9FpHlg7EujsUK9oy0iuuiMiyHxhvDVza0i5kDoWnfVpFllNsIHTwNg4wNI+ICRFOZHw xALmVMkc9F6GifvdE3Y5+pjmrEXVfsIBDKJ7rltJa9ziTaqHD/NBoQVj8NvRdRU+zdzk1qM+ dXp4JgHqjmvrVaLChqOCv92XDWSIISe8vsjQqkgANlU0k+gvRd2Qf2SajYuEDRmlvWCAlH89 t9KEePLRWFhzMbGZrFGdzlVlw4obtLGxd619ERzUg3cRPvYhw8o79r4KFgwSJ3cNCGqNcSQp ipzkUjOxOVnM4GHG0gtHa/IZjqrrIIOScBFAKneesquKTDYYegQSZLPTIDdvF0ITtHTitWUX FE6UA7STdu65We/Cim45r9WPoFpBDCTGs8AOacpr8vGUspq+N6fLpugfkcUxrV+Z9ub4Iq5j ETC58bR1yptg4sCOQwWq0syB+RzzWh7wK3jJzvKweh3Xm0MRDgowiWO28bfavuujhDgDs+ze 9sokgQMcPrNYK63lo6GjVUmgBBA1kfJTloz+fHE0Bfa7WAwop26JocrbyREz0RDjUkH5E0Jr 7AVDjA8FUEvQApQ9jGluOTLQURwjeDAGjG2tk0v1iAM6fp7+HoClPD83l2nK/ik77n6T0Mvw xnbPb6fi8Sb5e/CeTKsqM1YMo6HRp57zhLqVsEM9IBw3WFgyAwQgrxAPE0mFLr09tB34g2e9 JFasNekvF0gGkcd/m5xPNOgbqi2pV2dCNqIatexHh8LSuxU2LiCBPFdVvHy9eX2m5W9FGtmI 1fYWUOyZrUxo3igMrrbWgmZ8DPbhP3jMAoZh0jMlorZTHUbogYBFJKzp2OPLvqlSw2d+thVj p6UKbrJFWO/IX8O5NjoE/9M5/h6iDTsEs1wANY67LrpArY/bHK74Cudn187MBNcshX+MhAKQ z2He5Lh8l/eCttmaTReuZvbUFREWfqwhJTIv/vneiRdT8EMDztTaAUcn0O1z+aFQ1ShENkEX KHnmSQd4h6c7CzmSZ9C2zWDINXMEOkYfWG163i16+InE1eEykj5izYYj6MFvhGMgHOmWZE24 RQ1VsUvkoWDISu8x5LyABJGEL6YK5JzdCzYBh9H4bcBiotS9c7euwl6VxzZnVE3n0pKNpoJb wEBBpuIiiRB8Z8uZmMv/X1us82M3T517hgAMeiAp5EWztF6k2NALpEus8NUlhHf3IyNmcDde X6Lp/sAQoKSAyK/Oj5FmFRdhCRJuIWP695MJBEGEgrQSp7/O3kLD7GFq9ki6Cvy8X0GeD48v g2BOonOyhi52QQQW/McX7VjhEM53ggKOLSPbyRvoi6ksUNmxN6351eptDd9hosQ0jMmIvpX6 JmHxh2mFnb3lIXi0gkiNQ7lwvWcIcXzfFG8zeogfsPxoo1o5/GrcH1QherxlljNEyAws+v1S h1ledVq5dF7i5dvvcVe67dFkeK2JhoWvsjyVHAOrTlctJoTxZVfht0H+6/Fvni+EOA7xPlzZ RuF5pVkg0jVHgga0O0oNO9V/c2O0vCye0Z3IQHbpay1mv8ybKkh4TJnJoe1Q+8lqHhTxdY9S 1Mzv2nYoAgysOvLf2gO88bo9S8q92N2qDUQCd8556O4O1JrejIKCZ4dymCL5Xmamz4vfpwFM nK8Zz0Gu1+vVX64L0xIxMODz1AQUx6S5WCeRnIU3eB6hSSJ93tPi6lJEp6TSrNyopMVVBN1b LPQ/akBjmU/idP2g8RnMDD6/57oLlRjtel4+wQfzC6IFGiaPrgKyIMlFoMYT61B8LZDMr2Ii mP4Ew8rq0QDZ40AEwPSzkKI+/LeRv4r1IIuUwKqv6pxIPHk3Mr6us/NM0c2+ZA64s45hNVa8 uGIz2G5K4slqepaFHcXPSbZLG+kqF5stkjuSJHKtQVPHvjIocIDQokcbS7edjMOcbI/x5wAF 8CR1fWOtIjbmN7ZaopmyGqiTA7tMt+IDWLbVZEgO3j4gBxVGhvpmn3flbMqaoeK6cBNFgRDx ai/x3C3CSlIFu9qK+HwPAEBQyHHwZPdRa2iKjaXPvSWCF224jgjbqM7Qwt8J4m4RfLJaE8l0 K+tNMjZ5sJ/6D4bGZckX1F/pdq1ZVRY9Tz71O/R+ySgAcoSnj3jxUY8ylCAnqgb2Aa6OM4fX xqddFZHG61z4Un8Io892AOWhCrZLsv+zhnIkpdE0NTdiMm5W0GnvtKETWViHttyV2eW3BTIU vgMsZWoi4Fw8JUBYr+Pi6q+han/0b9JOV4ySKs6ux11qJU/FZjbS3+U3DUFgdl3cz11woHGN CtZDBjBCcJS/aJssYtFFjKzJ44YZ1urEWGj/D5tIQ4Qf3UQn6XiNgD8shFTWOZ/3CvF4TCLR oQGVwi//k+RWjjQKWiL/h/SqCjx8eP57wznNY7FEOgdiPlqovJw3I1qSa5X6RJkGMJkKF7ws Ua89Ke0fdGLFyEUGtWlyUVv9gWV2SAWxpUz+NcYGWJX48rXtG+QU4HaWvqOMDTWmlV71H4SS 4rgZ/+CDa+CodIwibnmulti1ae1YNkTKtjd363/W8Xfskw37C+n/eq3Q82LTtYJirgNZ5eFL XVW9NoLpSwBoxzxn1zCUra3G64kDVFLqOnCLlsY+K8Q9Ef4Yivu7IJNet/LKjnWUdBWddNqI gos+GtQBXSbQWoXiCJ1kYdQYGDKstdPDZbjZFaP1DklikTjKW08ckyRm/BEsNgOxjBt5WrXK ED1w1M7ojN20X5EubZVcVBEIRQ59C+AjVNL5nLatAZkLRa15wrmR7SeXKYQR20cPH5iR1sFY s+cZVutBbSe8J2KyVFmumxc/CBPKtlT/TnI3Q3DB/ujZ3253akH0KhohOoOGrPZUrVwn3KKq DKE1oKQ9QvHVThBehKX2TNYXCj+lKSSqXMT73KX3pw8HAxXin7v1nQGk6fub9eYlH32xngw0 n6uoIN0vkuyAUYKmHOqGZWFg+IGpMeVYP1cyA+a37+DCZpS6K1PLF1TbzIvrz6WGjJUTDaet iSo64Kqzh9rghYTLXJlp/k1QBLwAJ4g8MybV2jqPvm18axl6jtsjHKMv6lL1nWdy+t8nU/fs tORI0zIZzkk+a6vfYWhEvk55alkOSwQZK+3vhUtt/vLFBZuWhNTMWA7zkeQgGm/SXcPAP/U2 a7hhng/Cb3C5A3duW3UIewrvJH/fu0b8AqtSW52zehQnFRQy2TkAHAEeeEdqDDwSzkuh3vdM ZVLrIEXmg8+qk7fiaAW3tF+PB4nEruqCwnM72qLMZp7nyyaffdOb6S+sXhbqq5UiaiJthYaC BSHUgsR6c13joaq+1rIYFZaSC4T+OIajM2WnqFGoiTbvtH4DfLsehjD67Y/gO56a1dKQONf5 6inUNpBk4qxWBkkzV0TVJ4Equb8MaINER47ZjlQ8s51vp6UCsWvctlipoPw2GL+c3jw5ox3D z/gqgKdBx9I+7388ZFZJNmFeUGOr3ISrzuU88UZP5dcMY5Kth76uurShPp7uRgPGucAWIsl+ 7edLUzi+tWc0/fK6t9+v7KBuTDF+0o24csWSpC3/O0g6Oq58sxodx02NZnVp0IOSJXT1q0Xk 4fWWtuSX0ISLOQ3x/2g+nuLFVY6wVDoDxkcWRJflVE+XrveFiM6Y+QF8W64R8RjoL8hr1xB9 SngbB2UHOxS1VpWHfas0eDCbL+0awLZ+veVlcH8UVZb7pi24voUPf1CSXpYOIIXad9O3shn0 +78rGQSE/C3znvbvfrrZOzrOc23kl9O6EadCtpbpqln/+rsUiav0Ax7SP5vCmzkl0vGZbP4S yhiA8TOOdlv7XFJU/RaESgfeajLpckyjmI/OS7i1BHE06D7tjpvwhmNsisGlG28jGk+muMqZ Fihx95ikDvOmonimknOhbYZzabJLOjbbGr4R2vaY7nYPgfmLLDutlBHpiBSN/5WFTVP2JswE a3iR1JUWoWQPzrw/2Gm0CKC7xEK8vE1i57Vv2G4pO/ZQs32z8T81dEJE35aihBjK+07YssB0 PB5zqhRpUip/wDlGVGtGpreJaAlAehgjtH0P1rLiFYiw7GKtVQKXu3ypork1IV1QG35QvljO 9W1L0z/w88Pov926i/Ak9LruqAYDqkviXuzFXJAqE3/8ALpLjD7vNQfG50HgKKNPLeZ1+xtC 5dvd3NIgheAUhs93gt/k61dHbysYtlJtPZzCq+Lzyju3fhJmJMFg1zHAT9rRsWy8szBPl4oz 9OiuYBE2Fstuj7Zk7ygFs+EQqnm9bokLUGbivSaYMXy8iJod6B0ouvlIVyg/aXnOPwhjfh3o gxef2H/sMeBtVoSTkLsOdoe4pFkz5nBNd064kh1rvbeSWQzdvva/65+Wnlied1p4p6aOhoQk Log7JaijQRImdCiSIkvKLs57LniSD1+AsVCoS0FoI4sll1iTCd4vV/J47S1K1tOKbLt/CkF/ 2uBTa1nJuRWts97GeRrJ9V8dclTdJ4bYdbQnJ0saTET853rwjcGlLIAD/O1JqxoEj2KNY7zK V6cQFFELTLkzRjw0j3LT5P/b5oZ0UxyrLIX37XMez2pOIT6hcuKWGiOsNJwu/66Ltei8QDj8 3PWo9x+PZTcho/w5hgfvmjv/FF5vnCp6VtH+UsqBFgBmyM9/J1RLV6/thdraqik97kjkxFgD senq+AyGfFlFQnTCclC4l638LkUSuKzWNpf8hivD0RXqpWowz7ZRWUZ7v8JInsDUl/T4jwDt ZBRZnWEJe6sQ5TJ/l9oJ33crFB6teXCY//zZBS6Vq5UFklYDjRWN13nt4GR0NkRahfSu2/Gi L2Rdara1o3mO7LG7rBR9ouIt8xOaRB6krYLyLky+aVW0CwtyyWgv4zNvrBv6lj7e+Ho6QG/W gOWs7p8mKiwTS1eebrI4SD/Ee7xaCg1mXKV2VtDsw7RXy/p6ltJvDN355ckYci+UT213ephC TIvRsj4v33riubAShcnNSuigkcOQNCydLRG6sED+bBspAdUMSnACdYZ3p6RvzAIumGoR8iRl YhYkhqjEbatB+bD3Ps0bS79W9c6Nmr4P2PCZZsv7IkuhcmQsiFGB7JDEwcpBBtr9WjBdHnvr qHipYCHfSfLr5jmJG2Yqpv35i5BCUtcsqzlqDkOdgtO+9OkOoDguJmvFYoyvAjPzr+X8YP2U KnQsBHJVKlUuQ5ETSRMxpMGpH/g7SghIKb4IhN7s+ldVTGtjEZOEhVYWxBv/jAxGObBCtO7e cYYa3iunMbAF0torfTv5PFGeEo0GcKm1jmlAHLQXEq6MUxXc2bPuRzuyUdJfmit7QEjkSS1j T25FtA61i4WnbXyFSIePUCpHibjBHlecK41W1ljI4DABuMrIOKUsu3xScXrVxjarONkFvUVF vJFQmGdRKWLuab37jZeaXvh+nz20tRojk//gHQKIjuNJIQvf/pGuDlgi2j75nJX4xcUAwmkz qmun1YOqUPbl2N86t/LbyVQT3/PoEjgmsjo+VDbeTQLhWF778XOcYe6DC24B4Hd0S8HY8z3d PIwMMfJntkrIo7weISb6CMm6mEKka8C+j+UriWPe69Y/5oLOZH1IdZ6lGzaFY8GMKxRUXBvt XBbE4KghvzzJBwoD+nOneuMM6HBEft9L6XgDoxziq+710Vwjd966EEKCk7L08lJ+lhSIfrut lVRkktcYekZJbL6u77vHOq4r6esauj/msf/4G/3Xl6TeK3yvC26nC64I9aGr6RXAqXT+YnUs GYoo8ed6IgmAt+5oOx9oCWeqzX+rvWkX3cpPLjFWHRTxx9g+NSNRzxfhmxUxLcWRgVft+tav fPvxsRtWI3h+WmXScUvjEcLYW/rTZTspdKyRkbVuuTEVHTpUAAdBNL2mHreMQbR+artOZDC8 WAaDnWvIzZkaEWwjQBiE2D4yXzQApjmx44cfUpZbxmKsn949UFXhizHeZB/mFxs8G7gfdGo+ m44ww4A+vBO7HNUqFfRf/+UU75DrcJe9McB7ZfqnRZtgefoMstlr3Hpxpg2YN2oAsmtcBLV3 9yMM7Fb0D6M9+gVuRbiW9F1YPNgnBKr2LL3XnKiYAoIp+KUAa8qqPeX8vIYOA1HVRbmRSRtr 7EGpeLDMvxo+RgnAr7KNw3NJBldxPqX3wj/9SxoviOTQazSyZuwZ/D+nuZgA+zaJVf28QyS9 Yj/wIbCXDKBTt7fPA38pGEtKOticVneczGq46EMiKrKNOdgoBiB1q2u/Zqo5QhS8cgKMIWHQ KnPtx6SGObTispYmS7XJHrOzvjbI62cS2D1weaEFaQ6qZgE2JstFCZbn2RNWc2NuWBioeyxZ XtZd3WWBQL1zZK8WDSHyazsEAE/8E7nh8lde/aAT5Z2mtaD2byxvfLM2JxNQEh7Z5db7+uZm 6ibC6aSVF3S9wg95o73CvieyYWMgSn43fMs7187e2FC+Ee483dcwvJIUKsE+9Y4F014lzQMD aBYUVswKqzih3ZVZGR7b21uT85xrai0bEGqqzjQUA/qTZ7BThPFsEdZAgvVAh2V2AR+Gz8wo 5K7TFLq9Ea39lNUl3T5XuVxaZCZBqJxUuYgOBd2Y7uzbohFGOORbPvI+MvscksxospO/MmDI F+KX7kGEahBUAWBqv/EYAqt0BQj//1WTnEFvVewEb6LxYxASwzb2tJnmYn/ftuJbjf1L7xnA hYzJHoUossIVeSb16NVkqnQqZ9GicQEo59pZduZcPprbiXn+6nJ1ZeBIMytLEM7YzeT8NZLP DlaV7cXm4gQnpFEDQVdJ2Mx6mQYWAAUSOCS71L9AmMZEi/VIvOjbQ2STdHu36Vka8gfS407n C3aJS5LayqLPUdtsGbrRY3FfG6bSfG6I5YqOPIxt6S5AO1yYhjnSMhjyJEe5RLN+FLuCWAwU 9gXAIKdFqvSFsS+MEZUQjA7zn7QIC9SyXrm1RM2GW9eDPBPd8Q0AdO1hmrwpFC29NjO1pkOj vxFNYTvdC+FaQQcATcECUSsg9VUVzVxhv1xmNIbZARFCvPDX6kHYOAK3+HCBs3EdA7AuBXVR dzejpVFj+usOsKKKVcJnKavAZWACDVI5sEUlO31zfb3RRLF0j/deVZJSzEG4PPNmy710rAX8 PcTzrxa8pI34PUEW3/QmYmv3wUzwCajoDjtMir7JKXZwB+rKYXgXwjxyou8uwOamj3pMulYk uCqa3oWC14+Hbf3ZBgu3Bc7zdurI5rjx6HAwiLNmGhZHZsxLZxxnsfYIQ6ItDjcjO/+1WAf8 SjyUEtt7QQINhvAZ4mUGSp0m3ojHd9CRSTM3MNDYFTFiAN0ZYf2y4Ag1Qo5oir7ic1zwflOA iy4wWmL4sqxC0ZnH6KgC0H1gcB6zIW9zqpPv8Md1I+ZY8dP7gtVOg4nR+TWpPBZrqqkjgq+T zjsmgxmTqbrdJYOBvyfxFQzmuNiOA2RCliqulk+oksnSvgr4CeVuaeZW6SSV8K/KmxhkutVu 6O7hGBiT6UO02s8F1U0aQgDqiDmrERw3e2Ej3x/PmLdsUKfaZIh6JycgLpcD5FkGbunYNVMf xqqIKyD0Xvg7E056DjOtZOoVSsYTiyzZgcje1SExyDFEvk9O7agwVYlzVX2vnKTkU/VHoqCg 9N6whYMBVLNS3o05mW6g6CQpqQDqJeRwKhPNMtkqYRpGOtXKa36jGWB1iFC8+AIgYHn9YcRB nYW4OBWnc3Jnu+1w9Wjdk0Klph9unmTaL40oe0tPPSd4AHS7di9fQ6P3ajfNruzCueZgTi6H Y5DIEMTBWiOuygNG0gq3vmN/fRXzbxUWuynGLYoGop7/fufHDTnQ9f1XnzP+OWv5h1cdOXXI 12lI9XjfuHe1FO6Gbu3Qsni0ymSWLtkW7PSJ5MotMNlQyNaUBhXXhopqONRMni/9wnHGjwKP aShzSW4cIm3vwoe619kOR3TS5e7o8jv4MqFSxviCChNCRR0phzVDVOOb4CRlBVYFvm1VlVjd vcIVuBiwcCp7U8cffBfQ6iGd7tZeDW5ov0v8G40+rXFV6frqwcYsDsP8mesaR8PWq11BSINx VT8woyevfZZhtcLfRYv4BwcflNp3r5O1no1vsC1t/Gx5MUyCAIpYdbvnndYP9vhV7msA6NVu 0XeXvxzvgYDeXuZ+ZLPOmZeFxkEmGUxlwRczpw5cZwgJILiSV+c92TLHGlJV1DolRB55PElZ HRnmKQR4jPwbbDKxgM3dq/jHGHQOqdnddqeXReHqcZWlbQcAxTRZKN5hyJMZyGmbA9NhtQAN vE2+EQsNkJshNXL9zuU1ZTK4HucOXu/iaGn6AoPBJqvjAXtr8F8oe8ORD7vmMf7e5LI4wEoK gcJ1a9K2f4VrEOdZyM4p0iZ/1qkyU/BUa7HWvpmxsYp5Un0sbK9QeZq61pKiJ85zn8sdpGgJ HaNYJSjuJP6XRnaK2EJaCAtrokmLvbrWm0w63LmuW/BKyWP42XTQq2ZMvlgdiPjU3xR4UHRI Wvrz7YwmsCI6GRHZCzS/GCFmmnxOi6zU/GdOXmG8vADpOc8NBo1pBTRIg/285VMIz3OOPMQm fZUNvWceC50LnWUGQP6Mb8YE0pankmT2KCIn2bvTyMjLwaoSFd8DIDorfGDlvh4G8cNanQiU OZKJnoLne5PxpUcZmJ5pMFUHlOQqZsMhuo6Qo5vPH/CfTnk/OSzDxflltnC6SUU8ABaLvU6m nkzwxKYS+8PjeaX3tMDMrnVUzZljf7vdx9gRjHOcISaYCJhPdePPub6OGdRi5V42De61Cb7I thkMf+gkgP7MvG8F0YX1k2zfgu/bVeqUq18fTLssziA+IjJEX/G4ctUGxwDnWOEk7Lu6+gVR T+Yfs7HR9kpNAHCwPdhWg3kExM9Bf3HQF69THTaO4f2JU0Mt3ky+iOsUCh+f4CpDWK3BuR1E T0xnrfMl6728qLEiVoT15XVZCMxh5YToK0FPolJal3EM/CvqEtWOxuiwNBuQzrMwA8zBgC23 kjNJtrg+O8YbqsTRLFUWYN5tGn0o622LDF5f6LY7kG/GjqEHQK+7wGDv/40dGRPPfqLDJXYO SbYmsBYIweVa+QynI/au6EqIFJCfnRCbetnnP/9qZnQs5pq7h5G4SXJ+7HkxWHilD8vbwled 2ofcfxDjD8BKt9pEp3mM8Q5YB3Xasc0q6zZz7+xM+fzShMUE3LaLIKjYj71CQRk0HTIExkF4 4f+uhUuLAQXTTN/ZUZIULrnaSvFRaeykITKpUmFfBJoxML4Y+hnEVR7S8OsZZeai5nGhaNjO zoXOSRPEkd5DbT3an8iqzh8fhRzPZ0ur2VQCfdcv8v8JeSZpQwBbW50+Xvqi41tyklM5lSsn 8p7fhAx4x8m0QYh84ID7IXp5Tq3LxOHMDO1lmkCWnuaBbxoyWV32OmDHoPLiZSBo/MQIuIC8 JDRSr5LEH+v1Q5ZfMqlM+my8WER3JDBZ45XeN6Riza/ePBukzy3Aa4+XQRk3/oiII7KkkI5a SHPxcjoN0T0VY+LucDdIVfR1CELsywAbTQP3ZjiOermVvzZ8+FFchiJxFxoRs/dFAMYEQ0Ic hIWD8hrLKbtmxcTbcG316sMPjbD+5Lz1n/WYiBPDZaBi+9Om31+RQoTTEKtIqVz0MtBOK8ZH 0+/KNk+930pFHHuTQYysv/UOfLLg8xH/XR88rPJK+y9XA3zgBuLxz124+XiCHZHcbXNdrthT HocCTze/1T0lpzjCUfCODprogNOzwNdDrHCOAUGLKeMauGdubxTb7le6v2Xi9dsaL62jXNsw aXA4fJgvQRIA2vl7B53EkU5PM4ZfdH/QmmnSdHVW1uC5W0i7KBVjcLI/KSPMN/inGBw1Kbzg l9jopnQC/scsLsz8QHeTpp/1kk5bZ7YL0XgHKDikqejGc/jgEns0M5Le9ltRLYctQ1BpftOv uRRa4j9r8gxSYhe4QSOJct61nKLdWqM/RxzDiNwG69aQXC/nlNNkg1oidmEeOVaV0R5TcXUz dbbVQ8bl5tUL3VF4cxXSx0kdh1Z/A7QuP4z4XdTCiQeVrLXSDCgAh+I4JMHjlzkooCAownLb HGZpc6O38dx0CcDR3UC6kFvWrVXHMVxkozAbUwIrUHPm1CDvWx0sOPMbp+dvN+Cex5uCx5mr uTZxWT7IorRVXXQ2BW7sl+0nP/yN5ifi/pjpuvn2K7SS23HmAckfrOLcaJ3HXt+otdHAneJQ p8gbUwxuco9ZgoG4/1riZhIwhU563ls38JQVwA+HeE+sXL6bNwAe0x/FIc+DaFHMiDk7sErW 2RGIqa/sLykxOYfYovTE8R5hJNpCSXV0VbF+uJB3VZteDy3q3Z3+KYqcwOMO/C68q4DR6cDi bm3VmuiG28odyyiLn0PVv6Vw+ghqgqVdyxGoWd/A0/j+Z8N8mXXvkok2s4XlSaI1rzJcIQw7 j2K7Wm38APMpa3kIAInf3lhzMJ4AODvRFsQ+WEJIxGPvhlxb08GF15tpMYnwr3K+168UI05b muFSwsQ0NUsHcjw0T0WcJTBg7PCyPaGYK7Cvy0wcDI7R+HDHNSY+O69Ol9LThcqoE5Mr00ZF ymTo9hupzJzJb7VdVLsjkLiLzWHhxegiLHPKIj6o6IbGBr7v+yXYQfEEHnwr/WwmZ0xbZAWq zF1Na2eTJyyXCxXb0ci1lTYVaJPvvDmY5Wpb83Vk6p87jv2mfwvGX9Iyzwl6aM0PQhR/BaUk wMt/K2x88byDhX8H9g07TOW9a1Yw91ioHaaUuqduN2iSXTnZs3G4bTCbcUkEj7jrPBsZIN0A ToA6oYloemC0TPHQG/l+nFZF9/1tYRE033cQaWQePHeRCbGXRxn/Ugo4felWCbEMNNZvkeW3 YWfRelJz8oG0CuWT7ve2F6kJyrYMVsHhI5MBjKz5JkG5Ft3zYAsEkC1bkX+X0Tp02ZN6tGLL EeSXF4f0ydaKVzy+1v/pNHs9lgixVzK16RI3jQ6eQBtAKlphzZ9skGhqra+tctWVg7/l9Zlj AD/dy2gL466QDV0vyErNd2QFeW40bcsrG5R7aDeo1Iv4WJQR1uzNSdmLuPhi5rVKV+NCHiF1 21d6xF53px6c4lOtkEkzB4C8AJ8ZjPnxFRw9wY/SRB/BlU6w6iGF4Po2dzHjSGWTTADx51bK +upJdCH2iP9jK9eDmaYt1uqvQcXj7dZlnlAtPEAM6Tgi32KfDL965OukWGgQ4xWMQsMn/TEO PtXAaW3HNz/ZIeRSNJPfCzjGHR+z3CLSzJUU/ebhfMJdOQQRkcgskEuQ3+x1Xjz9xXX/QL5c FLvrzKlUxjwcXgul7zX4Jrx1tbEkmgWdO2luQoyL2IQsU0FAUcJI07SIQdYhEW3zLTh19BUu 0xOaBo+NKPN3yMZbJSyQSFn5yKQ9LvsctLGzby4MpqDfNZ9iEqCOaviEdEU/rAKWJ/gqmHKf gvQJlNNmhXWZjcIZmA8RhEkKg5YNm08oXGoO5ZbtixFyHiXg+T7Vrx1VYZzVzM4y25zMpBOe GPIwPpSz9GFPyxkTDOSJ8stmxLfqKfOAjwD+pMSOUt41u38YfZ0ACtbiskqgskeQKVaZYy+v m9Q3itvSMSJDhMqt31n3iou0MKAPNUQR5BcfPXkoe9vbHZZe482yQsQPyQnuoQZvg+zaNUEO nhTaTbCfo5XTBDzYVUPnzAiy/C3fg8ZRmFxGCIAZy6G45I106jQnre82iwdJ7p5S4by/e2h+ tCoWHL34oU1EnmO++EAdkB7IcyUI4Svdmyf1ZPCOyLhJH573kyB6Z+1P1FyDi6v+1/LgErK/ 9l0aRf6f/ROldPHNLsL/zTD4KdiMwZJs1n3AA9fXMVrgpkbNG7xAnbsR1FtIwWakzWHwdTqr JXGcio7DmmV49NZzpR/s1+v6dxP/FcUSK00KOuIHTve9yoEwjWQgcid5eGAKjWo8aYHDv5v2 VMBqdHeH3TI29g1rs1zy9F/FNwLkSA4lQcticOxCVi4nRIVdzoK9uXW6jT7mwt5LP3EVjbMa hUtA0HymS3LqaQVfy11UBpkXzHbzOLweuxTTrH6+F9hltvZNuOQkfSwI2stBK8IpJlUXVGmV PxJYv3xCMxrKGbJoFaEbwf5hUm9iG+i74z2N33UqttDvaXSDSVkqI1VMGeK+IBjuaXB9Le3O nW8LtfYOMOQsfsBFfOTckAvFnCkQbrwC0rJOE75s62ls+tAcsNdAOJyVcHcXbWjhTtE+YHWZ JJoULuJkJRqLtfJhaaWBoEZA+kredx0t8h4+lVONlL+hIeICYv6ujKpOAQpJUXC+3UcJ+8JU gn4zlAXHAKvZd/tibSPkUlNZN/T3UnMMluAf8qMmfHkfX9i+1MrWvG59v0CBE0jvSmChSY+P o4gTttyvEmlyZb8cZFIA6O1ek3jnfEQJyzHcGFn3QgrO4N7FFb6dvAf6W8qWJv6ld+Tckvlx JEsCAqxsVVPqPhZbPIZKowIkh5E1Dvv/g80uo2GGj4nXA9xv21bBzM0E/OciGuhlNUBzJbR4 hwtJ+4MD84Jbw7qdKU5H/1LLydGIzrchafc32QurhaVZcf6A+PtMvluZFMYkaba5I7JWrSON y0p/PS7U9pbAQRro8t2Luya0aV95tYlhFRdjTGqJVjKmcn0zzLFm06eF3xZHgOEEWaO0PDBd pf/+xV9pC09Dk5VaiVZIqqsy/BSPZN/opMyY7GGlQrAiXpvdaFrwwDmQgU8SEhfecdJd0Ii7 hkr7zrRx+pdFoBkiQGV3cGO5piieir7IzZPCwfIywM/YsBA7/n1FFSbngEIFYbKD9ZsJ5omk xo/3q31gB5CvAnV6ZjeS4L7WphrAIb0liDbzRPywJH5zMuTVTf/k8BhNJbF9B/cRwO4NwvhJ YamuNBJ96Lk4uja1FqipIKXqL+U6MKfvdYgTDsVfRD+xhxGg5vFN+MU7ex4ANNNyNMtTJUy2 b0qP8MTlqTsfhs6xeL7SADzKHZ1yX3ozdLzt5UFnx4wrXh2URhm9Slogf4kv3qw54dkoFJEE ODYakj0XnaqXSxup2MmNLW7Vem96VAaw9HihmC52XInZq/cCEwMDkmLh4pMCcuyhb2HvcXJz eJyt1cSft1atCcBGd+p+awu90tH8CPyeLiPueM2cwxoMDZXO9dTihKtHEas+X1QiRXKvwyJS E43avQQU1Y7hSjN1h11to4YazO3a74DSWVLF9UkemfeXGMcDxun08o5m+z4LczNGBm5hzD63 +PyCj3vcCCsvhy2JxrNzyccy28StYzCJeo9to5kcWaBpXA8vTwPdi1274/y0fGhWffXc26V1 8vKAWcpJxK4/72YFjc4cdzK0FuOmW63IruB833TploniucLIMwpxhfripvlEApktaue7acDE Im7oTSE6y2Rsv3hX0EsK2ge4qVRE08Ulx1RLjO3+Qs9CPJVSm7oAqjx0s+jZHaQ4KOkKPk4a reprsCfO5ELVVclt2mfnYBLihogJi0AYdsymS4ay/ZpRsSU7Hve/XAN3lfhLRQc17iK4W6f3 QchrGh58OQBV/lNx30aNjRj822g6IigJLfW5/kBLHcN4gHj1al1kPFUMc7vN0kYDWbylz/Ny D04DqfuP/+oQrk8SRPlf3tMS/sA0AUZePnBETt9Dyviz/tNOvKH45DSdrjIBnb11zUDMo4Zk 6YMcvQdop3IIz93sDxUdJBKM2MCwEZk0dhnwrx/07m5eWh10GdS5pl6lu1KkvvHqDThmoNpf jjtjtfSP6sCYL+BWlI+KadVd2yI5UONDSQPtcRC580TXctaTFwZxN50xA2Je+poyA+9azejf 8f67p4ZnSgsUM6Tn8EdkAy740vfWRk6kTae03kqNbZZSoyBEEquKOt4YKfCnZomTk/lsgg4W 18ng7XBmfmVDZAUUPt+Lobg6m7Kes0M4BnSmGrDDAwPMED71fz+1n36+NOo/kP2k+um/Pi1Q OOkI6LPz+SvsrD9yD8j4uQBpkYIcRzLTp4kKCHrzE5K0Oj8BjAriLscjRlyApTbdsa3QQBpX TBzCrd4Vx0rCYJ44ks2tJ44gGp7N3W1o2iQoeRVJFI7savMl/5bU78wD4hENFoWN5gyjIVNr 7e2dCPTiH0tyR7/z+GZhu1a/kGIRyCDBmZof6pq1n+y04yEgtJ9mKkLHM9pXes7mB7MbMnwm RwyENfV06UclJz3wgPHaXTV0DWUvNXV/OChqhr7AvfFN1USSSrMX+ASE2Nja047CORzFSxSa Ihd6qE1ruRq8XwhFZErdD0CcZXn0jHnvqZ30ov7d/lYqJQp1ufarqhTeQTYyni1QbuD9MukW iZE/36nmRvy6R/SqcIskXjiOPK+i/BAu3q+0CL1neoJG5yeqtpYJ0tNRUrR7IogJOCD0m6jc waLqQXOEGP91KesCBAJ3J89pvP3hYJA2NVnnppxK30L0UnUWa4ImtjN4GauWiSAFs6LKVf+0 F9N7VRrUFe6h+zVVuPz+Nj92DjZKMsawvCQItXHXF/+lP/Ywbs/8rj+qqHmWRGjqDcSVBErx XNeMnXf7NIv3153jBsX/dQWOas2/QHDd5+Qmj7JvNN1YAf/4b9q8J4JN5g8qdjpLAxTeQSrk zULGUi+TFm/8mcp1ijesjZDnwnMm4YBF/AbNpgt4B4UuSkGJg2NEVBlb5RZTSGbcbFEZjwJy 4wFoh21fLy8IqZbtWWZxDcC0in/OrxaaKBpF9UHoQPUFVMg8dInXVM6v/aNQIj5Oeh1sWgC9 IkiP5PtEyfXBKPbjgtN7k+ZSKszEa8hnzKTBwU5K35uNbx63YJ+j1mLfH1+3qL5XbruGYLX4 DgK5xjMjMAGzHRoktgJxFumwNbCnTdvPfWEcREWP+/o+p8KSh/KgCZymVSybcCw7cmuCg005 LbPKUeCBP/olxFREvo/HY7FbGjRDjvo3seleLAKZa+Un3WcrVG+BAQPuPJKo2Pml6FJqheyf BWgQOUlAMU2HeJ6yftgRuFc64cj8TAfjdaCywVwSdHw9yi40wSE8D9qoXoLFrXFLNrVqfRMk 9jz4Tai+OSoRYXQrrszAPGWxVOsiYywzFd9aHZ+AXkfQrY7FN//g0CNT/VgX0anpviqxtvFO oLRzc3S4QlFiyY2bDdmoxaJgOiG+UVqIy495fFkQVFnCl9tfG4M28EYP2+t4OUXQochlzOdY 34JPta+mmVOqC2SKaI1LorlqUNK10IvJmRKXWohhWVLfqo8w30YLDHFUIXIyHyLUE4EnloFN 8FLXsqYoYH3IqJEfZ5qYelmA4DAWX7N0roYIAuHqmTF1UwOpP7T78+swXoTw6rf8LU6+TKjs EiYjxF8RYJ482Gnlf4RsPyAjJzdkSs5UD5Z5+F73yTa32QUFoJ9PE4LDhDohPMRZW7NTsgIu VzfWiCVDK0aXZj4mboV+6eN9AFb+mKYo/G13pXMeasHXq97o3kzhUX2dEJsTA5UuG3NLyspS 1/Sl19eJKeumCggB/dzDZccRKiRVI4SBNyc48G7JdbK3xwn35JG0nNUunj8CN0dIywiaz23/ lGEJhMo3xuL0zMMCFOInTSShj2oHYZszlQVNP9A8Qa5ae5QNwdnUqz+cnXgMr9/jo79mvRIZ cCHLEycb3hW9gZhElWFYTRXBPhtd/UBzbHmJ7PsA+RnLoTNu5yZts+P3PI0CtSmooeBCd/vj PgtYkQFZ3r5yjTIcHmSH4xYmi4eIJaf9/aOg7tfDBXZhT/SAGTwL76VYBXOewPYkoYKRanej kzXkl7rzEJU7RZmq4jBeqoKbzex3ifWf7RniEBSW/c8OLosaeemgngIDjNGmQhbc8CWPpUQx IXpFiC3Bd8T6DvDiTpG5cj9c2RBV22NlTwBAWXQ1+WKqozLPye2sTp2kRR4f3rwFbtK0PeEf yjn4X1gA0+gJU4CHoMub6eUiW1Mzq8hnH3LpV2/0thi+uxn3IIgUUE6Z8pz8ZpboXfjttfaj jybSS+7r+0A7s3Es0xpWzXfRCpl0Au7QRmyleSvE6B1Jrxo5a9m3AD8Fps9wNojRPKkWPqXy 5nPIkxMDdBXHZyHLJGvsO3XV82RLDWYTZfCB1etVetBolTeTuzecK6Y019qwy8/uzaruMB3U qSHp+yKWBVwz0hIOlxrZ51VaC3oFk619aRwzI6I6A3iSR86pjl814i2CeyUL1b1ztKnunfMc MjsAJsIdlBsTGFquxAYhJtPyCaTCRl8ht7OUkkhpmqEq9GZDPSws5Zvns1c5Tuq0DADqkJ6m 6FmEDgAZ2ftEB9mlXmkWUVH2dU7BdGRuBziXz3fyeHm2UFBkTgPl2rMX7JCrxHw5M95XkmMI T5WVwRAFBJ5yrW8f99sub8ebfL/o8SDe6f2AUcqhGZaQs3dLBFlWV+up/JDUxKfy4LAsq/Hj m+v1qYaVZnItkNr7hmFS1ffSImANiodGVVMTvf2MINKHqCALahcfvGLqlbyfk5ev0SGOXwKX L/i/VHXxfVj7YKG8vB80V6OXT6iqXX3x/6NLxWxjVi6SpkrfIYR1Iu7/mgcMO0iflMXMeDJd HnllCpLGQp2QoYhgERwYflfhpsDCkweW7Lk86SYWl8gEogzTJCgSL6Gwng1ZnAYCAstMbC+X IfkaNFPt9eAZM4a4onuFu4kMIvGhnRw609ZNqZLUUMAp/WzyzZGYVBR2aYX2z0EynQ/BjVpt 4pPmkbhPMhJg5Ic+lUoVZPLCy73jNOd66dp2MEUcvwdl0VYSHEi/eFvL0xq0TH8xhkY8NQKh /rIJ3WXZqxPNE1kKIAnDYHeD22MLzyloDQ3FatOLAtIotDLug5hfBLoLsvRV11kXpRbccM0T QYwSUd6wWkQbAb5d4oZQJDJX/LH/Qal9fEk7hO83Jktk+JFQwTj9Pt6jN8KGI5Z1/lB6I5Np kNF+mp/DcB+QSUuBjfxasjDAwDCpjHUQQvUpoxVczsXm1sOOy2WL2SSEdspUA+62V8SC9kWE ZrjZiyUYXgf3rULsOW5BIOTJ3Y263PjEAC5V3B792g6387tlUfkXqsaEv2oc7wJ74PAmH7dU LMpEkbpRB777fdIv7TWr0o8gaBqBWHtz2A1jKy7TycQqnKviWI/eFr7OH1FXxuqwD4taogXC fOTGorkpc6J+aYBuQKPDho19NB6g0FTNA0ljuv2cctE5zM1owtdYiupy1y2f/8tl7lFa6nnV xKQGpeLdGzQQhZzETH0POh8h0LYpEF+QF5Icoqtkxw7cT7NFqnoh/wSNgHkJfNkkQ/KqsH+6 WyTd3pyLdcxUrLtBcoJDqICKX11pbs7s750uHzGSK402D8AwoMugLffkJLnTtknFkyxOTsYC O8NLiykGVecCx5driRV6X+xt+WWAqgrzhNvY8M4DgBz1SwlargpbKMOGxkq9g3ZhITMaVCeC ISAfc+DPjQ9xKVjmOrJZabWh5biKW8Yr4CjOISGiWZB5BzynYthyLuuRvPbrfnUJJADJiIGy yK8g3PNzhgwa2g3YiO9bQP+v6FNQeKHqftAEhXICQILtkcA5XYlxDHLK9axge71R0sWP3Z/A Yo88o1woQx8b0ftPYDHTFMZT51MPpQfw0l9wwkeaHZyZaf1SHxy2bCajWpAtSThQZXamDRWz p/jjhVlK1j+c8cBwKQKxVMvLrSj1aIE0ZokeUGVfirBaOKSOW+wWEq3Rzg/68wEN8wmZGUlz dC6jz0yxTY3V+NxH1dInhomvOiSa5aHLKoZpXuVG7/VIfl4vUDEU63KM7+hoIyLthG4TsqoC fXFHt5VKOAWw9lqXkct/KLkgwqyeQDihY4Hn/jWp7/KN3f16P3iyLHMmkA604WEilw89cZ0a 29Y/PW1NoM8tuxdPB7hQxmNcmRrYZdfUu3/K/JAHFCNtSTor4xqawjZ9lOY9GBN1hF9q3vHm 5GytIwfqIt3EeDirN+qabMj7pPMqICQq6gOdi/gs1hB0WWI6RBuT5nhGk7NlxiiRieeee16j LZi2fOcj2th6nSa1AcIP/Aa3CCXmYu4S/BRyHwJX1egNockMNsHPn5Hwb4MT+M1/a25txz7x xt3UlKegOw8HtTc1DL1UJ5vBbHtC4nWr7tZhFr9BjWvwSs1Qn7aXq+nDxuloUvsHLEqmyQdt UvBhazHsC4rkBVFSMoM0fUcaSKIV/PT22qE9fETzP52kUhAJ+KvYvVipYPDUHh/VQLnSVD5S uJUpPoiMtC9B28ApkD86Ym+aVs406Xdyy4YWQEZnl72WaToIL9NabEmi/HVmOGO6FU3x+jzH 4DOm/xMKOnxep4gb7o5ep9Z+Iqbs1mhmc8u2LvTzjqRANeNjGzBimAd8pyA6ncpfDwnm8EwN 4fcKxw5Nrxe+6O34Tcm+sr5v/+N2ITLuX7TvZyAWfR/8r6Yr4HbrktEYnDSSKyBmUsmDjZ6U fKWq0tan7SCUVq+Wgo2QBIurthMIzk9YzjkoQlsSkvwoPlrfTioflNh3zhQrMskKSAkAdZ2n 8dznnlS8l3GAn+jLJry9tW6XshqwSnPO93J2fb4B4gubxpI1OHDDmW2xBy30nEku1tn/Rhm6 VOa8/p1Wo37PiMMY3tdXqNgdeuGygI3B3sR+gFzIgmM/z7qRSGdaNIP4cRwThQogOZqesdRW xT2899Wuwn3R+Q7w7qF2QDGl3LuxvBfi+FtrKwT2zzQEbgRe73kNAwJoBS8vCSxswIksko4U H/sXJM5jtaTwgtZJ5DPoNm+weYSx6FYmh0OcTiGQ56KIGwqnh+LRlc07E6DgfFNt2gHhAPT1 CWsywx6xFI8z4KOzAC9YM+EyvPZMUPm2v09PiNVTLxJM2wMvo5bBL2PXSkoXZkzkqpob0IYn b9KINMsVtqZJ/hNMVXTvZj+qENV8cvR6hMAHZfrPbUm9H0dKN2cFLRPfQvgHDwb+AYvaJZal nhNwJMW4/z8l/NL5i7tsrETYPkMxV2+aBnda349sRU0o+XFBCN1CxqQtXRidDl/iPO0uDaKz HA9GsS5WsyAsJsvkARXRX9exMrxft9yGRl616+TJHgIrN6dvfmUqW2aBWmAYMWUdlXIEXjs9 aAClH3cS3t3WiQWVrcTWxCb9DcB3CELNc85Nj4vwv7Ty6nwKL/Gfb6KkHwMgMKhOsAHeGYlC Ej1BRX37IlHBfs1NCBaBbJ6oUt4f+IIIIRNBD08whN4h7KZtUgKe3pyGKvquTyOJtN2P3kqH kpUMlmsngVg0Ym/PeXWa13tvwjvaNy7Nyhk80w6Q/HYs9b2om18T4MuaM0s1Hx6Fp2LKeD9c vpuPhLKBeEJ9l5JMwY3zPtPSn//udFTvAgUpNGx4GMltC2YxBNVSUzbIq995smrRt/OoShke LbkExQeG5yHWNrJVoAkAIsbXfWgfy2n/lAeKxdE2XU3a4zYEAX/6qt6JapUHtAks1Clv/Kc2 /2DkMbcCCMOaNr0l8l9wQbYjLvT5NCpm0CaXdz4dYP4gAPuIstaUH6g4rYJMSurAWeNgSkS2 +Iu5L2532oUEapa9VgPganktcukxwXRquu57+QbU4OqjVsxFhVVzDEJfz85h6xCZUjW95TdW C4PWXnae1/w7q2QebCbjoQvkFLiHtj9jAIvYuzLnvVNvfRFMEr9TtkM1z+a25Xf8DODmDkke PI/y0gMCQgIgBQ033cKeeHMG9FudGVFR5yDLieyEDu/2AOQB3Aqz7jwzK5C1NyDWWaB9E70b H0Qu4DZFnNFwSG75PWiJPUAhqRuPhRneKBNCUd6QFTiN5tqku35csZ60ZRTfwMHU3GKlpRFz lz0Jg55Whc5exdU76V3nZiSEDav60MZy2X3irrIb/vsScb3DXI21Oc1dB9lFfHgvEp/6Cyqa UZJQiFoxRcnSBmq77eMWjVMIR7Gtch+puLPPoa1ghiCpNt4MynvwmGH4ft+HR8iPSsVAu7LT po09oYLKbI9atLTTMFBvx3ooqh64Y0QKX+Nd8KT3xTcxGKeZBc7ZpVpgfN7qMtl4WFGd+7mO sKahGfZ4dqsvPxLR+T9YetU5PJFGDvJtLeoLTkuVzDW0+gRWw5ENSXoEqG99Iz9l/nOeQ7qr o9PvZHTutbEN/i6WnNaU9fRHgaZKIpS39mRqB8FKFAGHePmUgpvetFcbtb83AzAX5vCKzBiG hPTl2ZK3HGf1w9buj36zqIl0d72cmNNaiiW1dmMQXXw0JFr0KpGciMeNRy4UGY+apnxZYART L4ZHwmQTiiMcNs3HFdNv7kJQNmD55Qd6AXfT+murMKPKSBdt4tzV4GrT5S36jNyL0/noTQkU xUhCZIHKG+SWgi0UIx435Wqcd5ECfHIJkJ5YIfNvoS+57V6Fo+UV8bTHDELXlrQhGGX7VZxi gKW5jxlg0ZZI3w/ygGKMwUaiPJ3tbejWGumIDgIEV/IWYg80YG1kvVK4PO4dFfS7XWhTRc9Q zXhjomPj3awfC7pfHJrygiRN/Mi18l/fgPCd5CfdmZDXLL9t4XbqvpwlB4mE316SPDfXBG72 fn2zZmoLO5F5+b+vJIXsAqwx4cHSasn8OeR2ea8kipzbf9w849d7zx0UqcR7/pKhyUmc9wmY KccjicRa1/DvLjPYUodEzSgdNTjHbj6idQkV9ZyJufGVj2itsiawvrSDLLcg2O7rKZODc1/R XaBGLjZaYlIEKIePf5FiEAnGABDjjyASfyK0o7r3hTz1aqejKrCLxkEHXcS305UT+JLs+96p ymoSlYW7LMXHTO40eylCKg1BkoQPHi5le5pd+HpNbNNbHxlm0nTsbU7K1lOITdBS+sLvJLXC 0PcpPcYg5sruROlF6Nzkc/ZhPtbpBbCgvrdUcl3gcXvmnTaGwsl4znKlpjYAhesBv5EODpKA l/oNh2+up4+Uz3Ek2Htq4hkahy5W4PcjvCOJW+3m/P0CGbL7Rxt5HRc3GgOyPxFsaZJiackp x2LH6gYrKGcvgo2kdsWUdFb5Gk04n1VbNN7nIvj3q51BwO5LwMKQQidW5FLIMLH4EmA17I8k l/2w4XDBec3NHPJhbcEQtewMhp9n3h7CcxkQyWFD5G09DOvN6N4xth4jUK3EZFDyDGRM18YN B9+Cis1Ga4wBxWc1BDxDDHcRz43nU7A06PpeuVkW52AB7VuGCstW4YJOJ4/yu5MQDEqeFXAv v2NEbBI8nWJkhdBYgv2Ab7CW0qFIf3Pw3eXdNsF63tJkohHBTLdAt8rWfUl/aqjjnrxatwon sGbTAV1DipynEGswpLbn7U/kB1WykWy4DEsDeDfq4QENJ/LvR+UWUbnpNFn/iZh4z7O9Jc5V unSguwFVBe2f5gU0+QNvC5Sff4U/zvC/WKZDnjZNjd6iKcJPf09EXToGvrWA1AYg0W4pCfiP lTKrI5G9tBLVAMalJcnl/Ak9noznyXtgy9lK8NHaXSp2XvScht+Z4ERBSzB63gMEzNhkkzx+ wDQj9jlth7Bninva1CtWTIR4zO0PsKl5c0TRHwLR3l/yIp7xNpqrWOu+Gv5AAtLAzsWfh70R ybcBket60l5NlKiVAsyoIGH0WT59Nnoh6+hGYuLNm5mibw6+iBjao0afQZPBUXpov7BhoBqC sOU92qyzG6qMM0i/aHFOTsNglJ3+VdIvuaQp663Bzp12oYD3rjciIToPA8mHzZE9ZOBMP03L mONV1GtktO52pzY5pOjyTHQJmMsl86qUk7usHnQ9VgtsLfK7h7HDgWq8bu3npNViCsta2aO3 NCcRGg91y7HVDfHyxYO2Rum1EDVEQcG3KBzj0IB0hmDp4sNYvrM0b0lVmAUvAOmsnp0kned/ dD70lBne1hy9MqPFTHThCkclrKhOdS0tIs/oEf7CT20YzJWTJ2YffajIIveWc2kUB5ok0lY1 0qTQ7At332b0TGsunzWvg0TN2vVkQN7H2EU2cgpetPJTInwIHG6gvnP/jKTcgH+wiNm8zC8s MB57S0293bsg0p53JLBtMfr+TC6fvr1gW6LYXXo/uASuXgtwb5eNNX826L6JvAYtq6Q1MzjG QbfV35+0aV8CWucz8sDlHCWmEJZr6WuiQhVzzlPxPa3xt/rK3i3R/pEQN34sh/4ZS6GV2PU0 Rmgcq0OMIAGvMjGfk24O8IMfVNglhB0nZGm0doIlRpgLcUghiKFZ0K14Mruswuhw9HiIzMAK s/Kj+3Fx90eCXK26fU7XV32y0LTWUQpxpVOmY88u3z+HZWD/8iuZ6jD/ha7UMY7iF304IfRr OrK2bRAhRkleFEJzq+kPIKNJ8Nfuzci9KaoJxCUepgdVNmOAX19hMd91yKq+BKnaDhQ+SFpA 0pT+9vcjixdO7Q9mUDwIzt5hBOMt2HnR+LUTJIhdnIfrQ4qzYGHmx+wIaX5CeQjBIuXZNhXL kypkX3hR3KUCG5HtgB0ZLxcAhVKrTxk961Y6+al+8w4dh/uCyjRC/Shyp2WTSj5Kqay61Qn4 +WefRJvw3B+SEfECKkVmfkdqhiN8ra1M6PvOdTqt26WtqadkrGYnWLnvcyS5eFGNxh+TsfH4 pfGTHNO3eppWTFtMH7uJMltM763LKk4c2jPmIrvoM1ZkKJpUt//HpbO4djZO0IOZxK1QH8Te WszquXr31WMqo6p8a/VCgLT19K+7ObVKcvd/wu17YhGu6cYyIwdt0beUrxDaBDX2dYmEjXj1 UPoVKbrlA6aGBerwgw+eoEfEowaMA09/vHwFg1ggZjYnPmuXMv8BDRx03K1L8+FCmxsNUnLT g1dVM/Nxg0d8sWIN2IgBFYJIIjDcfkA+p00gz7danCDcFcy79rtDKYk49Y988nmXl6suYowh udmyVgkispPHriWoqSChk01kYVFHBpc0hAixtwH2ErNtsLFL/NC1CUAaQT0OSAbRcPJ8TMAs OXEZ/ES7u1cXMXuPFHGXvm72Yq6rnDtxa1Ij+YKHNB0KulBGOwn+MpIB/Ua9we2x1BGGoxx8 czCzoY/baSaHtXwCVleR0j7F8NHskYWITWk6/pPNppaZcb9XyCq4RmF2CKP6/u6kMCu4tNv2 hCXsFhs2mDek/zrA3NzuirACYcNn2CTDGakTWzwaMvhmqxwFWbJWTsVfFfxUYFQn3SaBQ4I5 /y6qqVtXigp+ghhQ4u8lPrkYVrqzJ5lbiElSkqMd/hX8QNc47m2YVu4wTyHiAZZUxSGikQsg 4pLDITl+j9Kr2DvQilBD1AXqOpPBqW+t2shE5gQUDlOyC8SeA4c+7ruLMB+cuKPdxH8waz0O zJleGXVymkZJ3dJbSZVBVnTc0xpLJQXk8Rf6PBGCLl5qdVODuedwgLiDk52rlpkZXpQsW5w9 xx025rb0NPrQBVMhXHf7ovHKNxVnBmTiQbrEzxP3cleo2SzmHVXHoF7wR/sqZyyKBG1eOi2O 6DqpxZsM/95OvnqnzezXJvqxjVkBKNGwfRhBOZX+T1HSogf8xaMLWt9j7kmRrb9LHjZLTzVq diEHB2SRpG5aKX0IY79JBX/fl9NXePh4xsWaCJ9TudUjxBmPsy83sJSL7Be6X7+Xcjbu2/99 7pJ2wCRdCHzaf1zwbvzl3ZxdmTIVo87XtrxzwIJKC9PNXSCzNrzWwkfIVX/q3TFUjkvjises 4LRe1Hr1PGd8t0OEkgivbEzgcwfCSkHN/rU6h+nr0HKI2idLXqsvOkayRdTtvoUPKL8TuC21 rDdklVVQgYCyjLQSnkWOJsHiD25Z3XGoTyT/4mQpF/N5Nwevk7EDVR3NoKlg0KHgPBRSkKYT GOrhxPOE2ICm4by76OcD+zW/IFwoay0UwVKjWoWgmssad4JR0OANFdwq+x0QjFXQZSsIp2WX qz8Umje0gNfA9rkcb0m41G5bUyDzC8C1BKDV62Il/ozw5I2DhSpQ7f2PcxQ400tO9GAUS/yM ngvtTbWrbYrUknKdzv73gXnNWCNaMX1jSdbNW1m360CL/0Cm++K+Rjqxj0iCYC+kVBOVNTua jMxrIqGLhei9BEaEpaL4DxSEv5mDkW41CQpVYBE9TAJ5v9/pGy5GuZ+giBR2gT8nGJvVTuTS FKjxAINfN5lKZGfTNavyG9a+HDcyjmimVqBSGPahqlGndJYIlAWCiLQRqFx8ir8GGCyob21j kVUtKxbE2jHnwI+z2RddGp4eSuuJGTlN+27UvB3qVSL7GKhVKXQMHThpsWnE9/f9G6zlTLgn IOZRWO7DIhWo80oNj5VI0c9vWkgusKIwJVyYhBr2ZoP2XvG1QfY3Dr0JdoZuOquNCoMbHgoJ fH/piRPEzoT/ZVTkQwyvmUYCme9gZHFRsnHAJvSES4N0/cuso/xUiLcp8twM3EovMXLKOfEy w6pebWkhSe9wC2ypUtuQAIherhU+Eniuu2JKGfF04cdgSBslZ0lhYwixM9NA5RSIZj4HqEyC e74pamLTrjJD7hIaUS8G1M4ko13XB3sxCsWv2TxzSx9tedIL5UkclY0RUe+XwxCUy65TTebe b101uTlcI0uI18mjp9mx2wSSccRxusK8+c5sKkgKjo1q7LQO/qZDn132Er+8Zm/h1spSgrd0 PEoyIeZD2YAepMYaSc8G99QTCyzwYwyxfEaW1aJWyerFOoPz/6tUcE97T53w1zKw7Nl6L3Gy 1lMV23NSfZ79QUqkaURAT2I0OPzy1GMEA+d/EF0EVScVoILiLrHvh9GR0zGYVSCoA1OzrV56 krkaADhU5rPzCRr8AQM6CVFMVz7jTu20TdYKAurgDNAOmKU6tTWoUSBKwgp3m6HFtIpWpRdx UXM+qytouGbSkENKzTHewGEhz/dSPmGl34xLMnOHgIHOxaTTdONhXoS2wwFRwfAAxRJywPEG HjYzOECkaHcYPaBWV53UtOoLXGHqcHMZAY9eFWCZeb9WnJSIV9Phdz7gx++GKA6LNzvfrbj/ 24D2U+lHQknPEzGAPE2TBIlsBVQWR7Y7ECEnA6/JuFqapy7DJxikGqiWw7qhVc1glpYmD0lw gns/ZFLMGu1qnRRMKQZGaDJZwGVwclpj7ovSJw56zJbMfWR0QpyIfhWMJ4+qeXHp23uACf+O 9A88oiNeZY/zOGMx5yeZ4qN0MSbKJv38vfjr7W7L/f9DikhYLO7twxBgswJklHT12mtW4gWA VbKkckifcOjr6OfFdIB038uonMi9/gqlKIp63IZGizpxNpG0/yhBG1H8PBZD4zg1kdRxS5YA 1Ub+ewUCaVMS9uFRzuSq+DerUlXNkdiBD+ZnopBPRQ0i2uHc1Kifj3nd3MGrGXeXALOVS3lt RlU3ieJNUc6g0CUoshiIolSgHha0xeLTkMRumwQuThxF6So+/OqPEa6v98v4ENUVQGZJm+M4 tp+o1CsKbz53iRj6D+Iy/5W/TUPOV4ECXaT1GTTYmjSoOVBahvVWs4wb5dfcVO9wYskdQc/Q nd2PED74xLUmV+MTK/Ak0yQCZ2Who8Km1OFQdn/yaV8goSYGBaHX4ZitInKMV0KbJR2h5dlE pPeiaiZXhPxchJrvJnjUSf7VmsTrNnU0SqkqHbAXdXhxJcHbdPfaNZFsFZQnxdpyKSKZKpDJ 8cp+J9lGyPi6xbHzlB4KiyrpCwR8pUyId6/oFZtXgI939USqCoACYIpbzHo6ZzQJnqk147JV C8C+JAaaABWResONV0QkPpGay39Y+ucNAjOZd4R+INvLDGD14tWxw/GfX4sNmhHQKwY4ZPfe PS8gob+T7cnkBWXpWGL59qYIXJPQQQAjcCtePa9cUNPah1zuGBDY/kUIbXtK26y0R9mJmyWn UInV2Xl988gOCUQIcuqnTfhbtXvYNI9I0RY2ipPZHhVxOG1kMAJiHiYWtJg/Mwj2iMOfVybP Pb1EdEdHiz/s+yvrks5ZYK18LOATrQVCcit2NqOCmHNQEfGeM20GI2/SVxEUL+Vq9DPzFzwE wSl898vfF3r5TlWNNEPfXhE5T8tfbAlpMkiRnPGi1gisVExreAD1YH243dgF/hSHxN+KTDSk SYJgPv5Baoej/7NR4b9KHgZrU3agmylofUhEjmM15GdXg+w/CKM7hKLUml5q5oBnQmB0wsmN ZasDa8B0SwKrpe+meXUwiKlqfqQcKFW5Z0Em95/7nDeGEvI6fIrBeYKs0TqVbtJvCexGfxq0 V0wh7QUAXqgMb90VSH/q3rWftltzUZbrs21HFz74IgE+KRnHoxjnklCWyr8Dmh/kLBOBmWGA HAhskTbbeG1sLe1fnIY3TVYvbtYFqActX6QjNdM0a/31c59aStN4D7WUGmZ6Usuot3SN77TC qlTQV7TzPh1fttBtr9MjQ72kT/AiYS6GQFMDiCKSItJmbpmY1HFOv2ItH2RJY+j44bOrM/3C liN05TTTPvSLdqqm729InMOGfNnDCtF368SpDRXUOGRnulV98AAc8mCvFH9BFwkfwyHzGxmE aDongwRMh+/7Iv1n4Ex+9qXoQt83J8km5O6VzKgHDMvCMtNceqg6+Yu8z3K1T19lRZp3WTR0 gKt7DBoEku8d6F94d/1eapazp5bBi/6tw50BUwYPa8vhKuT6AXaThOz28enquCZQAYg+GaU6 k/0qAiSf+v+RiQmjK1FcGnFEuYQqIn3GSN+JT532ex9VdXrP/6DyK5mgyZGt8etoqCAWgvSx 1IizR4PtzPAuwWR+8ZTyRWxXf8zEnLMenBuzcBbEiEwlExex8+azH+YAp2owST8btLIFp/Y7 8rGiHaqyyTkbX7IY+v0I27MnSqpDS3Y/Xi+rGCVazQUgB/V1soKnIqgD1Vgj8sE9zIaYvmGV ye/YoXKXw+iZZfQVqJs0SfIETw/AuXTecLYADXyxwFUZib2rRAWf3TPTNsk0CbhqfuLqV5Jh XnT1zTB34C2QMG94I0apDYpAUCp+g6pInbgHc0O8B1eFt8R+mzJX7A6XtxJLtpm92mRXjkMW RXfujv4OUyoHsjXlyl+bPiSkpbPJStz5tc7rH5RDXXqwIXjezpCQPj+ao+7hRWlk0lHkm/vZ Dfrx/LdpTkaSUZdOrNwEnMZWF5A+6YqXdLEk0+b+cMQHxMw6edFsFopsFIa9K9FV+b/UOukF NeWKQGojtbK+qoMZH8YOu2N0ws6IXZN/StW6UQz0iR/y0edkOmo0Xyi3+y54TEbZzLHyA1sY 7PRH5La3dKEJF9KuTY/0h32mvxIlhz9FZZC0I2GtVTQyJHRZb7in7pUNczG65NwjLiPx/t+9 cG+9T3C66Vs/owMwl0PnGyhirOpisCLCs5MUVnZ3KCuzAJdX9vq0Fd93EaRfaTlsEg00HPcm Z5qr2zy1HEkZL+7TlGA0FKPte/SFQzJBebZmrua6evQjS25ptwbjiIQWhAOI8muPEdR/UQGi Ci5rfFevs49aFo1cc/zLUq4KT/6hUZR5PRR28xOzLg6cf8oicDgq+dM3VKjbh5L6fizgr18n A62AJSVVpfdMyRcoTSCDSyjYqQPjeBiFqmasq0qSWHpfloDLo0r2odxXFDBIFA12GiyQilBm WcefWEmbQx9lhIHggBZv3JvL46f5MRqpGKREAk2eblmLNQjV0etAyl0XWDriUw7r3hN0HP1g WqhFLCaB9loplBwMwOx18lcV3tPl+3CG8WesdyYmYyMBbj+SEGJSdJPLIR5rWfmKSW/w7f7q MaCxlzzIjFaxHzw0zfV+E5ZXQe5FMFFSWDU10OzqoMUxMyigtRTA9J40t08+fPApLWAS2bcv GORMvA7VrrkTNM0865a5DKo3ONcaac6S9MHl073/geYiSHxkoZuAPPyDiCtm1p7Lj7fVxvAi UMa+3hufhP/i3Q923gr+87rrd8BLzrr4UV9RYfKM5RCdbdF7oyF6S+l/zf33Ryiij4X9y/p9 TWJYqBUflwpz7oKNK+/EslQPdB5pgaFYUjwIDSQvBm3k5Tv/A4oisOJHOY8ck87/iLJlj3h/ Jjd4NPRwgE+iPhfsw3soSPKlU7e9B8JxbA+w2Af9NjhEJ0Rag4I3KIrPTUEbxc5S8Nfk43+V 7UeGsbNXMhkh55VHfGTvwUS2T9Y90DOiaKoWxnSTW8nOtBB1l6ui74/sTovKrivOYGm5D7MS ML09Rqqfqe+TY/7QrBVF/DZbMVTNd8xcAWndjv/LCeId5kT5T5mSXbRs3orjd8dbfnZ2t/dS evSEhhLRiqA1jNTDtMRvKYVRvlVwQmwNgOrGvH5BgiS8kpr8tS91H8YGL6mphzOLEzr2UJv3 r6BSKtjX/dU1e+ocslPB8c+DPdBRsEn984i5KuVbIsgazw3nWTlZWIb3YmVmJd1a3pGhMS7G z9YTiTw/Z09IQKCREwb/xzddqEmZQQrTyvpWCHv02rNTnsyX9PRgLT/V46zJLLkqLpQhn8/N Pp2TImcKkQ2qah/uhmb3FSOJGo4RhENNsf9xWsBpEtNHQprc7slTd1OOvBfpxj6HONW+WXX6 9x5gjKV3WRUdFvH5eYSpX3Llz9awTgNdXxSI9wOLPyvdMxy9by93mLehU8Vt1OitLICBlyL1 YwDoMdiTLWAgbsl+lWwiDxz0iWxOPEfohQthpeM6FjIsix1lupTw90ifjECZ6s+6JjfHFCez xyQRv4SLm6jHxdMyUiCzkfcDp3DW1rOm7It3Y9lpO18+8sLgdtGQb+Ok1K3b+VxU5h89x5On 9nZJq+XTd8O7aLd1nDkTtcoMgmZ/nVCxDc4c6+lWrKcZXZmO6Ih2Xxh+Nl2goczyFtouZ8Mx vboPY1nSlmcQ/7VpSDUgVMeNEsZD/f88Mnc67RCrIE+ruMlxRNMrvwCD1MmgvyXcaqlcgzvB XT9s2trkkc1g/9DqzBFodwWkXnAaPOntvr5vrBeZog0r+qhOUQm6Myf2BOi/mDD+HVqdvcop WtEGiWcmdXKjCZl4/kIrcFpJH6+Ey5TqZBID8P0QdVudrk2MkO+r8a3GGdSff2XGis8T2+rH ggw9u9DdFuRlnJlhK4DHIOArVs9w9Un7UI/1urXfRvx2F/VrSim1ad5pFumkjbDgPpiRwRfq ytCFxVzHOTaPbTNok6/0k2zT9sL8LbyCLVLHLNWG2l+Ynr7cT7guasZZVmfl3g+9A8BLcsjV fRAi/ng2BP5rqXncT+4OsCzKbQNqnmkrT/ALy3MuuYuWmpDErPvU039d6/5s6dIyw1ttQTzk 7mekB5ZbW7iphF76yMjFdecyRJ/dHC51c3R6U99BOeXFsLuuIBqE76MScP4DK0R7DAGB0ze+ 3HPAvxXKg9U56T7LeMdtNfaEn36Jc3oDgQRg0eNN12v57VzppVJM/PDKTSM8iclDwMKJ1XdX uOCW6BoXJiR8qO2RVL9Fvpif2JpjwerZhCShUZ9CfpYD85p1y9P1MhPVm2fUFXTgvOI7TxN6 mpWUkU4Ni2ICt/i/AgccRUr9boX774gqk1yNOoZybDWuO6vdp8LSYl5zWejawmu5qASLXnEP Gc852PWWEKWMIXhUNUBxdsJa+Q+WwVSjjPiTAfyvfh2IF/CJJNL9sq9PUFtcEEPgghjz/MFC ttVPdmj6Ss5TJoU9w5AnFNN/auEKg0qwb8E2CcjmyEMjNxGFbcaogndtSEEVQ3ijDohsPZTS 0b3SyzWInLgoptyEWYKTnc+uFVz0k3ap58S/HvTN6ha4xMOv4N6tDd+OMoX73jls5ZTM4Ehr NedQIm//9I/BbSdJe2343WyzYoe+AI7E9BLnw3gFrEmOLKthM+YA7Y+diavHW7BizCZOKQlI ldHtKh7IMnA9olVF+YmlZ7YMW0Vz5ghWjxTysvlgMGzFwIhN91l3soegHHs0PpEdI4TPDiA8 UqPcG84joQyntc9RKzUg0S9eQHy/5Veuzb0KBPyXZWoTiuubKHUalFihbxFvpG8kOEZuVZKg wpP3mznnT2FLAcEu6MS5vNbIN6aYWTRtgOH/hrd7iNR84CcXHdSk57sWyDBkSuIHCE9nyRJn tHMEchAjGhlbSjqOwfW7BqZGMEGXxi8jrMeRt0Y1znmWo3klp4+iE6KbdL52nVp986IhGm+k DXYJ9hu6FUmoHsQ3zCfrTu+o7An5KQwmw3wj2Q2X4GdVVpIimImmgIy4Cyi7MFCFmnYQhW2e D9FaKAaL+r4uwcAFec0ZyFkGs/u6EIlNzayICDqVRA3co890vj9LILBoD39D53RiZzVKZ/py YOIMHcd53TlxOpc/SyabmVjGfAnfIuI+pAECgtjNRRHBjAOPGxb+Ldxv0DoZeEsq37X75Sw2 G91eEjn4QrDvik8CAq/GCkeQDh+yYeQNWHws4AOG/QxQ3LgF4F+hb44lXzLWh9xHlZmu5nfF yZGfiKJpuzHD6CNIuCvLtR1vhH5X3tZQQ7OuE9RMhVwPRjQfdA8PSJk28wI0UrUEDhX8Tbm8 mFoKS5V3SPcJ1Wu2NjBBnumr5PtX5aetpneior6MxWChWjbT68CKF4CKSJY9oLNCH2DXiPxl MHKP9ylSmbXp90HSxDMJB+7unzsvX0bQbUVZ2eiWdO7FPGokMbciO6fUpoJNcx098pqVJoeN ngfpE4wfj+hfhwM+6kc2du3BOdIdAmLuzxlHMXCk0IiwGQw1IFlUVGWu8Y/OHSPmV2aG0jbD f63btFjQYPVGAXuHfIxwJoWRiNCOZnzSfxNGgItKqHszX0ayIcQLPnC8cHqt/0I63l0rBoMn 0i9D8F7AZtak1D5rbK9hrSGNlwanrVOQfITjphVEf9q4t3nlYY9RuwFzeEM9YGnezxiyR1xi ossnylgg7OArIm805L1PAkvSJgb4S6zNy4zwJM0PK6Y/4ReS9Wjf8cKlgsAQpkyUsqjw0T0m QbBGft4Pnd4i7r/pm/V2REo5dwXSt4rHLBcn6xImy4FF6GfRDpKlnTF/eUC675+UHfzz6HkF 5qT032XBF+v1Y86/MKCopgteoo0i/fQo7l/rKwkPSyAbAwqQXnlOPXpAMOby6bZXq9Ax3QKb /SOmDT5rM6TRmw92sD8mH50Qe7BOQp+Goy4XH+TeOhtMg6NYOPMlwJM0RzMxOVQIryHkOdND 0ewL1Rhqz9Ric7ky1qHaKlQZeLz5V0wOk5ukbxMj8m/5pdlrkQHWYg4V7YFFqXxZD2HBdGIe VBetz3e2M90GOTWdHMvgrYXkT5qvn+aP320wBP7HgCBH+Q8AX91qFcJD3XsN7sGUif/dU+9o dx3h3zV9ElU21Wh4sDWFCgQ1nyTjaM0h+XZz5qsrDhoNksBomJcBdGda6Cv85BiSmY1iPmiQ /KAiXimtarvAjpawyuIgJcIAuAPws9PzfBeiOFc8SWHdqt7nzOn+LR6ugYldkTuZTK63hc07 rEdn7cIeXvrZRr0FOcgFyoKpjvF/8XhilyS7fVtGE9RgblktDsiLqz4Qn9UGycWWuBIluncT VlYm9Jna2MJm809F2dQy3LPr8aZ1QCwIJZHgmhiRlPlEPQ1xeV3VfCiQy2GSPkY042gY+Zp1 RrVFoNWq+xaQ+IdfGBGfTsxTaavI4ylDySReq5Mivh7o85uusMQNMszqSzGoAfUf1DmRK6fy HjyKoJ4vjWTTkyP7W1yKuXN20atO6cJ7z2n/xT4uT6axpozNZBQbPjZN1i4iI3RumYTXu4hM uxVCnPLBzyVocudbOq/jjEHjWh8WQzz7v25yj3wUg67vR2Z9ESbYd9CJ+Bpy3A1clMj5Hz/W Z9DidYLWtq2ISg4btZrKvCGo7IOCa8KYjfmsyhD7lmySB7R13/2Lm+ZpiymhsmzaEFyB1CVl 5w6+K5I7FDthsq/DGYlu71XXH46En4pNEWHWHAdoeeoQjjKgqKYxgHGB8De+s2kyKUKLwzX/ 2o36NCKQzK3639JiTpAg96zlvaJKFUAKPsnyV5oDP9lbDY2SUFptfvtdzn3fU5Zn0eA0QNT6 D4HQpvhMzl7VdXwJaWnw9KebGFPIqwFNTgizuo3D+GJfwQzyW9zDKVGE3iz1AgF2f6Fer0oA RVPo8vQ984xSi3NRuYFcKLFJo8/MyRrTfS1XRdluZqF3pWGxEbH0r6hE/kE8Ruhwp9FKh3Rz yHMvwpnxkxDq4NDpbIY9Fh334WMuKGqyTSAjTwIBib+YLWRTbnJxdqYC0oG1ZdRSuzeM4BCH i3fHHE4ivbMuFFsl8KzLufTb6Yd7M2pyaLMmZC4e79ioDWNUxUDgorO6J3d+7LkQNLPMx1Kt rGv2iqGczf1YNwr0ecGy4pL1vb1p2eERQ7wtTKyYVl+xBdSTnfJ4XY/Dp0JoTWnphcOSvLAn CodUEDnV3R8WAKMiVn6gMYXXP2L32fUD/ZiGCJJ0EOBQkfBMdbcmhKZavlgJdaLgkegvtgu0 /Hux+jsataicnYpB8epEau2tl0gcs5iIyYL1qp0HLeGDR8KVn+XxtXl3JOuczRam8+tmf4sN J3qEz0II3fnxSFYCuJpJohHFnL9WmeFjUp4Xo0ydHSOeEG8B+Eq9NsEIBbqZOTyJJo20nI2T P7p1IZNfS0uXMkkT3flcuhG8Ke6d3F1mhJiA9CPTT+z386dahzz7Njyvmu7EkBx6K646tXWP hr6LJE3+pkuAbOVyhOJrZTVZGDTtVGB/MDRmc27fqlHSOMm37ijzTRVNaxPqonZXgu8SGtDu ZeimgnbY6+oIOF7da8fec6o4SNvDBeH7X6NHZcn7I1PWXHhpC7soOCwA64FNl1adz7v16QFg XSrR2EBPETlfcDLADq7oB2ibgaciXN+Bb/l4B9VtPOA6Q2IESFtbvhB6TQ1zRa11IYfBnFMM l0WFrm9UQZLoOEoH/yjLpWPgbOain5XSI8yJmEPDH3a5v2ImT8cmQ9+pwPpKvG2MPiB02rQs 8nEog2HrFp/nW9CRhAXNXgOcQ4C8Cxc86etxDQDo3q70x53UjoN/VZAt8UttcRHMJWr9icbP 3jOtCU9MkuPZSEgNcv6DaJncBUFwH+wtDdB/36wgF3ajYoallsmHVod3F0SLl8GxHp7Xiiqp Stt0oEPWH9+9JUB5g84o1IeVBSCniNo0ak39YAnBndrP8K8HyXkDPkd8UJAR+hOG7cetlFr8 Bt7UQNyVmtLH7MpVXTJ6tKc5bhZx4378AdAa2uOyMvU5OczHpX1bRPW8I3KvEJ295lB0GAc4 SojYY60e1h4nOZ2vc4MIR9Ha+2+pjsCXpSyv5p9CehrEvE4xlw+C4X5TgQW/qYt15XnMxb7A l1JguIdyqUGgOFXk54/XMzMnVRdvCyhECDlT+X560TNa5ntTeTGq+G6BZzKkOM+ZGCCPWxV4 U9Mk8Pev/7qlnAJAmIh+A53U6P/0itN4v5l0tnjcWRvUml7ziIw8EyLljraJv4Onkzf5+vdr 0LwkjfbYsiFTONTWUAUYsIar4VM397+G7B6SZWJ1Dj3MhTnj92ySLSofVl9q9r+BCR2Ol20o dZyyKCAA0HsvzXfjmt2yEZ4U7IYYyB6mjf5r6zXhyUjqe5QewSm2gEURIbXTql3VA5pnr9cR 1jDQjYqWn/9OE1AA8/G7mPyFxn+ldABo6+axDFzjP4UUXLzvFTS1nr0B8oWkTfqCaOFCCdMB /4zep6l5FQllj2ruxWm7FvHetWSTWhrRXiLR8DvbBRj/I72ea7uv/xskGCvbeChrbG7rlTfT 0b6ry0VN/Sqd8Ia5Zv2EeRMGbHKtlmlvM2OoIrJi+bdt/UwqMaLp4TgnzODt0wCABkIgPwf3 5Bu8fon1LOaXVUk9BdYqJ55mjZBy6gnCn7Vmk06WFrn3mOswa5vbsRZe2pVoRV2V+/iBXQjx x+XcWV0bShC92YgRS6vG+UK5pYf0LHExyZAVf/CnWJvHLyh+3WtZNj4Un8ZuBV7PNarSv9WJ iLxqd1WePTzZ1BFdOEv0i54VO7uLXmKKEGunWslDWiRhEKejlM5OVfa+Qmt+z0qX0LMUb11A mDEvhlfgE+b/66ZbVVyMm4+xbcq5vOSIidZro1SCxZ+bEr+3bSpuHn0iHDSMtoO4UTeavcqx Jm8ft1EC4aJPUhjaIJINdCyY76dTH5hq9oH2b1igQh78z1ci1UbzVID74B7AwE0RI402awNg 3kDri+NJrDiWJ7MZLIM809hgYkCQY5ihL/no3t1Vq0NSmAxu/X1f1LunTvxkrp1f3BFVXW7F nSBWEXD1fJ8COZhRGIm9rP8UgrFZtcsSj8uBsvlqne/cO8rtv6yNTYWjwD2hyKWGVpRlqH7I selZL15FTKJIwkfdb7EfsvArLvhVTNArNXgvzJ4Q0vvIIciJP3+VSf4XODCHWS9XOMlOy5fd mn9wIKgoS6ft/vIFBHql2nvu1NS6H1dSKuJIZ95o5ANo5cFnCC/vZee9BRhLk205gHow96mU iCRxcNAdhSF62htXYYzQeTZBnE9u/L6VtDdN7aX1vHnTWz+HZQEHggMN2gh8yz+blZGyXrHa iQDgik2qv9ezRFv3ufizvpzQT2Sh4uymz5zJ58jWRqGJwWaZuE09WL/bysABueMUVYEC1WCH uWE25baN6VmUHrAIvpIIdRfo9b6kZIJUruCFhseXg/gqo/pSZGeNp/iTsfX1Yt++Wgon7yH/ joT53QrGQK7Q7QmPJuVE1n5y/giVQiqZ8YcIgLTJ9cMZ2/8Y0qMPtVZIuwIL7055t8XcCsdm cbS8Xsl9h0OHqlUHSh3xIyuLmn0o6dyC3SG9RA7hWCIkU2zg+9kMHYyLX4Zs21eeExVwqKwy aGMQzsyOl9baDtUnklj07QkRxOeLNMxfQKp17Z98gU6HCRCqxJ3gjMuzLiLIIJ8falsIyw8G t2jQoHjLj4aQBIOxxET6s6PgT0yKhDubNB0CeN6o2ws4RqBSeLqHQXsw7hbou1DWEcUk1ETE H7cJBfgEjfsl+yhv8KhOX77NJoCfswt7lDDciOxsXHpB5NM4DndHmLVwF24JIEeaQesRBW0G xylftMoC2yqhcWVC1WvaFpC9TmG8o+H8Pw9FVn203w4x8N+Al+bBrgUpXZfhVIOsINhC/Evs 8Nm7efjovqtd5xhjLJMc36/EeVYnYeh+PuORQDRSjj5XeUwOPbOITAcLhXt7TfXGpMjLfToI nEwPgNUrAxxOP5BSGrG6/5vluojDxdPoNd3ObkMfYrU+65YOSRCN0vX7fdxzVPKzXwdoXnAs UEu4DQvnQPpyqHr/miHv5JMidXcOReHGbkCaONsqq5bOQUPl50quV38+BjxDHRzBVj9qTyxE 4RT/iqTn98C6RiqkL2HUogbaxZzTzlwBZBXL4Pw1UJQ1MHDMKoYJ2cLiPWI0u5UO9SM1+pJ8 nv3PqNfEkwlW3ROSmDONPZD7rSXFNlQver2wWf84eZb5QBpvslaIIKm0fs7P1J/tRk89XyLA hhlS+iASAKETg2jEbEUmfxgMAV69g1zL+qmjJMIyP883cxsIbW499r/tVCn54gGJ1eXJVKsP h5VzZPkbxzekTQG4yZmo8EWoGsuqmfs1TOcJrcKsh5SMyieyjzAtKzkxWu94lSadqoEEpQOJ Fj+D0Wjl4Ow07CflmqtdAOu07dHFHHtLtWNCF1/et3dC2DrHZI2kZkyBeFVqfEdCzeL6rP2F 7x47GlIaPJTzmmfw+PmS0OVfJFrWi8Y5+nawkia84mQTPNsOg5ZGR79QE8nP3CZQZsKgPWpW hlWJoZNfc6MlpqYYdOsXSYDPbXFf2LVvJL7L7M39RCqs6Bn/n2jUoR8QNJZcE3wAdFUpyk19 YIzgt3O+6BjaDpbqKUYb1DZY7q6CjQ/O/WaDVYi8JB1ZkebsemNzF8i1ij3HNS4lHjGYQexK +1jKEd2x9E3AnU4zB9Z+1kfJ4bt48PjJWUaSrkoSdBFoSibHwVYqq6/6cId/p57BfrjPs8Kc uki/jdrD76wI/ZeQ+E/PFzMJ5yx6RLP1ydsJlxXWDZiyWFnv7vmXvT5lCFMsIxP/V18Ueh6q Xwi0ZBMLrycHhWcdkeHaHjM0eptbmEFqUgDBTAgLEgFEkWqt/Px3A65ONz8H5bL5Fn+3B1J3 OAglvqJYzJV8iAOa7X/rOLR8Y6aeqX6U+enLZOPRP71hwAel3wWp7aUstyvO7aOpExsYrcDL m5xAWzMJxo1FL16Wba04IOvNvESwcVfdA//t0G/azZw2LAS2r30q0QJ5ClQIg2BrsamNlWOh SqZWB2orMuXOIKQf/hDZyuiR9afGwnkbGhzlv8pdBrs/TqbXtNxXJhxK8J7f/MOuA8Yr50VF xmtlp0SlGOzA3AURuAOqk8+0oarhdMhKioSlT3e0gvzaoP6PJF2w997xYgBlFeV3/pIXxAVQ ohN5me5k9hbuvlYO2WGfvTmDh1BJhkvRDpWNPjCnVhoJokKcw9/eALCO9pK7L5JrRVrqa0LV OMrbZ2XYVxs03l4LlAK5qQKmQMdr7RmidEdr+i401wHTe54F8ghp2nGjapjLP7wGZlLxyWeo 5qS/kD/DWrvoUbi7JOlGerhQv+gtQ/94PCK8FU/26sfn11syvw5skpD6EuRSEWpGEz5CgrXM X4/7gIWI/VRKaJwzfzGa/TgUKUE8cFozxasCWFKAtwHQuUgphhci7MqPiMSHLFcymUEB4B2f pTrbqvFwgAJ8U5FfIE6FlzdI2SgR/97iMAKf9Ar/bet6fUeI4fyuKVCyW1cqsh+Q0feo3kES +rXzLKZiYgKvbuoVR+8bI2XahmBF/XpXI1MQgIwVJ7IdNI8YwSsarjl6J0OBIGw+76Z7Drly Yiyx/b9LfbLu3XN5Muhd3DlPhPefi9ynYa7/YuATGaIcp81MZkXMwJ8b2x4zHPGpoAiAFB67 FjhwjuY9qk1nsPk3pShCris2W2xvwnJ0stAZb0qMstB2InA6ffdUvWjK8iDrRlZvsMOimXbG C/2WS9REciuHVhguBTo/lg4umANWS1IsHQoDSCooH0CKxh5WrHBGgiYYCeO8VURFMCRa4ur9 uVKkf/gy6E3zrq11RkvuXXEQrIfRyU2NxxIYL2qE4AAscbq/nEtQg1JzJWvyCoz10f2ewVZf nx+ihGOUSDdgcKZK3fIFz3KxwJc6W5x69ND5jy6MgAhfh1nS+01M4PFqE/opfAKIqwKeLH3A Utgp55HlWqZDhVZmQ4yPdRtRQTJs167kiRqPvW3HB+A9sUZjXz6ChjGSbVJCjMQ2LO8HmOsS gAaz89bqHDF9o327HrwDvWla/TLg+Jh5CjJei1W6lwpPMnXOPvAh3Vhi/LaLwZpicfc908Dq Lf4JTnowLsUTzlGYNdKdAP/sHvStByyCNEWRqhXGPn9Q02B1nWwJKTcTJX7Dq3qiouQe9i0W VfAPQtFFXHQKXcGDMeR5TeAccoFV5LkXOc4/Tzy83hQPIUyzWBX4P+u18SN2p9uTZl4mT9Q4 O25owJcomrHgbQZFYViHHdA6B2O4wZ6mO0lNZbxOEP2yaHk/6A3bZ6zpFFxof2WYsr4xyPj3 ZCf8+OHEzluRO60nokCv6ErrwutZE7u5dYuo416Rnjw4bJM0ZXxgYk9AFmAsKR0CKYJfL/8X KKow+VG7WW9N8td+fntkbZigVQxEPCCe26Z5ddoPKGUu5OPOHQgv19XZV4rdDfXwkFFDkTOo bx482sxjEzsYv6RZ2Y+kpSred4gXmyQfSzbONKOAD1C4EXSEu9dLQ5Lck4RxKO/fFM9TB0Nq MPxywXWuplpDcdz/ONI3nu7/c04/sjVEQTiJf/dp9QtW0c2KEu6tQ2Dn+D5B1amEVuKcm2jb l34IYg6JZ1VCyis4okLhaUFwQpNUkZDjbZ0yoBLj/axWBY9M9bl4Gg1qMvdqJN3hPoZBCLrL oUg52wQZhSEPWRDTa+3UFMQXgied4xcKJve/GHTd2ib8coZgQm8qbRObC/FgW1BxWizluu8t F5U6svy/jWy+OQkt/Vh/msnx2PauvV9mnzVqd1SBksxPcd563MxGTmUe4/8r2x+qq8f27aFs KRIOqbM6dB8MLF8B0lJNpCVRzv8x7Jq5a42RpMK++KWVhJ2cxgaQdOlL8xPiKYekg2t+9qXY IM9jxGLqrMUl5hB964xU2FySOx7Pcjw4AUekIoic3eCzh51dsrpl3sc6aoMee3hN2foBLezl dFQktgE6s5U9Z0FvMDDfCW4MlWvSIzVOjJ/54iZZUlN5OEfVbDIwOkd5OsBxMLAi0MgfCgCa Dec+MWTvRP2pBT4xERZuCp/Vhm0/Yfx92zTaLmRL85JQpuEnk5vMj84eN0i4GaSg18q+Ag4u qllz1oD2MHdhOjxjDLWgmEg5y1sPGYIHA8xVeK2G/B8pJUv+LiHHUAFYxkoYIPWYcDJQMUWJ v1heSDZ5Y8zufA1V7vSkNw0n8CZ9Hlsz60Lh7FWSvVFRhbmLF4fOLapWOKBwNzL13bNcV1c/ AuAir8CsWcCaE9rkIijU2q4+U/zYFRtug+7MbdCBNJdSgi5fSoRh8T72Vd2SYwV0I5BWTF5S Eoi6yReTDnNaVOhCmd586tJMC4s3T/I2RioQ1Q8UvetFGdGcQLE5p0S1bB6PPK149t4iMPbP euxSFsQGxMszmBWcZmvRISrhRsu6mt0APmCi6uzyy8LLsv4niWWxXsQYf4k2FQJ1pzFBIG6Y Zm9zxh3uZ+Wb8hQfeRRlaB4LAZ0puiiJfK9gY4WBT6T7yOfIAAL1Jbgil4e/ZqTvdR22J9OM GbGSC9FIDNhD+8UwQdrmgVvho712x0tjgsGgr2XQPn5Ve1yS6E3b7YhrB7c/PUIlR3gvSsPv Ph9FOF+Uw2UH8qTVGJMbsZIF2242SQniNgR8c8gR5vtMci+5MWDNjK+T/ElcU8sqlkcW97/W TvziE7gvInbAHZws/y6MgB4YbXEHci5pHA6l89aUxf+cCsXlepuKlBAKllJ3sgX8yW+WAHIU Rh3Di1b5dZAPp2SRqolGs4khxPaTj6/Od0vfVqZ60x381vORPQMJMHjSTDbxfnG3bn74OYLv DhQQP4uaOXYqT0DMBg/cJa+jnQVBPSYQ3mJXqS3cMiaDldqe5qUsSaPMInhh05JXu9bwDamg Hu1cpY/7YAbok+n0B08RFqB3u2m3LsahQnaSmn577dc0N6NgkVnVBBSzfVWuNfGUa8fNcHio /yAVJ+GeFobeOOApiv1muxKYK0+XsTqaosPPVD66uNfzGqoiCTog/+MIBA2VowGGrOuqlI0I G9b1vl9mnUoHcFH4GuHRn5yixarabGGyWfNmqyJCzcyhD0scyV5yoXnaMv11AE/DmJtNsOpn GAAl3N9JG3NPz1b0KXokRCok6omUSinHwm95Kh3J5JK3XjHQwTRHk1O+565vEdoqQVjl3yLH 5+BVDTzRgDC/LDtIuFaOBlVD0mPpx7uBM9Bu/scQMLRrsmqETNNs1lsEYl7jKi8pqr21+dup 0YGVIgAwewOm7udayVWJbE5YH5R/ovTBR3N//2FJdzwH3j49TkpHIk0PcqWpc4QLAu5NrJI5 GPwcMNi7UlIvJqnhj5RftK1gm96V9hC/5tTHyXE+5B8XE0KvlhkvbZJGgrxIxFQacR0hJu9s Ff+V6qMZRc45Csm4b1ITCULbZHKiJogCUrz7jtlTq4aaDobMRQCZfuwx8XcIsFS4MzqbnKsS NwAP1HPQKpPtmoW1zW4QjxgqeCU8MrMOmUxamY+kugwp/e+V+m6fvrPPpOGUfJ0jFE++vRSk QegnVmPeUCapzz8oxLJw9/eUrrhIwH6fMTjmrvmza4nuNWGZGORi8Th8jgnpnl4oHveIQbLH E0vECARjsyAsvVjNkgVmU69uARrDBgnRA2p2ZSEZ+2wz33v4V7AVyPJdU5TfImcZMh4vZwuB u/qckoGIt9cpVo4upFV7kxKGmzCVeejd5+piQNwk1toS4K+ZOeWp+JjFqJDgpQJK/siozDp+ E7zQ0kK5wF2yTfPjCyPm6MWei06y/6Hap7IaZVwetpzl3gitWV3gStCgBmFlx49rsM5k66Oa SpgFK1qJYZDV3XjbMCjwQ0kNxSj2u2+Sf2n1d3TG7d7fIUF5xmzpoGjcZBUYxb4zkiNbUtA1 U3zOWuTa1TEE2R4jouaZqdJ2udG1dAKtmb6oPUDpLVoyIx052eiOPooZn/95JnYA8UwC6hbK yWY6owUX6i4SgdcnBDruWCzzXWGglvYsNPjZQthB2UVKCsyHU6nxQvYYwlFHHGZCd/gfJsou UhUFmJ5E3cK23lAAnv4+PXzLZH9GXe6Ss81bcn6zkcWqJxhTIjOTL+zVdnp5ez77kM3+NzrU SLIL6O3+tHaBzGVN125GgJa8nT0pNRSaj2XHrkYvHzYQx5IwUE2q5McI5PxK6KkGDOFKmg+m naCAnDTTebj2j6E5G4NV5DRR6rxe6fNYcnRztIle9+RJ/fBNEmZBQnwCShuMWwqob0dF2U+p VvixYQWwPvHWVBtbcxALQ/iz57EOK0MQgOEfLtARikOsVRn7cl9p/rL9BLSlwFy0695i7Z+a rMs1O17AmAYTC+QCo+662qkBxAhPaaYUtAiNKMTo51cZeUaKSPI+6tWLAXnCW2tCaEbFuRhc wg1tsSdu135cpfeCNmrTyoLK/Qtcb+pUH/Jfi3mG05wZ3O2RYZvS0A1+QHMxjUujRK0nLa06 H2dqrC9qOPoagv4jb7z0zi5J3qBqG/zqH0BnK+bKjKEn2hNfibR4q58IjHk66NzkZXg0reDI LFC7rgznqSgFUdkGbwpimik+vYfXH02Vej4mYitcncGLEN9f3aNSVWAU8ZetjFqUYUHJxaw9 bXCEY0K/K4t68/CRtZhXu1kjW3QnHGGf1aOOoaAWNkY6Z9uxat9Ke/ab7afL3wc6fAe0CLnl LsFw/wjII9X66FNPjGfvaLspauWYz9YxEat6lmbh9ponGLijJvkSIGU6X+0i+GJVp97HOlUw v9YGND3kK441yu2lsU1jfu6MOSKhqTI6zTxdjb7o3WLAfKv5cBxBP9h0ZjE/28Rt0uSwrHew N/t8lZrggYh+eE1WuhDUXNyv0Rxx6eV9xbSjkUp1h/IspWyDHxemJD85zU++KCMRm6pJkp2H fk4CVifsgq+wD3OAQSfcc+fhwrijFSm+ZHTE4z10cL6VzZXPF/1B430fFA4/bthwu6w31VOO 4HQEAvNNbW0nG8FSgcWRG0ZOZ0WnlqbKyo0bsjLoqAvQKmwdbgOtGS8rkZ71c9ztJC+HLIDu 0frkRoUqkYxQT+ly+N5PhTB2ePBFITJnEwk5GpZIcP9ZLFHkElNjJ2IeLcRnZVuMEeS6vX40 AvyiaD65wCR8FwyG0m99CLWUZJSY8F6ZSexepbNKiFC9o0gEnq/YqGGI4YnplAPCcfoG1elo WZMBS+guvJtfRMq3hFWNn27RtiX4yaQwbd5jHQJ8mmNy06fOY0iNdkvc6bRM6Tu5SJKe/f/t uwYgtcUMZ7u5M6Y+Dyx8HK0BqnNrCUOb0DjoZ8fXWjyTAo1bMPMyYE2W3/kw34z97/j1N4Jt I8vnZankc/lJN2CfzHFQI5sHGXeja6ugn1SerMSEVnCLgDu1chSS3sEHWnjPUbv4sa4SGGB/ 4HUmU//VN6oO05VdQMpd8Xyqp9jFnuAAg6e08qeR5/AEzYHXWcQwcG+XsP/gaKlRk5SoRhUX RxVAqAP8A1wQi9iSMuikKK84Hr93EmozQP0OIdgRpK0pKkcywRHgLyROEjcn0vgLuAS+9six tUE4zjoipKsIi2UHG45KNE0/8/u0sQWnazzf1Iz2bfZdHa2AE0jHkKnGP1Uy2YRqElPEuGJG BsasXWWijimy2mhk1GjjQfL08a4pWi8juH9yb5taKcesPfmkxNkgAuPeXt2r/z/WOJAhV2Yg qhveY0bnPGPguOXb/nXHMEU79INfZcmolb9CzOSVr4Ms/OudIUfE8AtLi0smjB84nMhFR/Zu cHezalOpK4vOWanc/iAZvRi/1jH9SP8L/7BSP3NuOIgjzSRN8ahEjKams3s2DpuZdh/0zUYj t3Li1tea5vx4WQjaQROHI5uePhxF9TgGevTYKvE/Dls8I87XG/DIBzI6R9Ml/F7py9Nm6eGn +x3n57ag3SjVUHzUELVI/uVTMfjYHGmYHl2k7q8aI6hEhI3jVFneZl/tKkmWGJx7+p+2GIam 37fsQ2sliS8FFfNaH1QbtSUE8eqhvlJ00VrTnVHiB16rPVnZNRxR28VFQfepdw4Vuhe/28sr CMLZ78rZ4NcK2QgSKXvyPElAhE6b+GPR1Ih2P0yh5z0QtNkdSquaBw4V0UG38Fxf2ZJC0lGb NVvHJSsBcI1sJbQbhz6DGQeYQexOcBWukag1cLJTjokaSgyVdQeDCgfZldAvIlEQYIa7j9c2 3LdYk10Q/nGSEQQ3NpLfDKu33ocwtD3GTDaVJBHr3XbSPvyOEAyS+0sklkkXMoyfuyozukup d/YK8SvpKxrW05hLn+u7BPX0gpFEE09vpAmgLftpfuDUtDiDM5mb7lDABys3BPwbsNmcE8mb W5gW5j+uh53aJlq2YbsY7vB6/4mLGwKaDT3radShKWZdSWmi0LnuJ4+YDKjF9y8FKS+Lie3b umFfXDq1DMh4v4P+ij6dCT5wfLPcisEy2rCOKV+gNUdBCFKM2f4zwAZ4IS8jFwf2SY9a1+yQ UQAzYLFcAIqRBT31p7KiFqF+9Ql5Nyoquml94YZz5BZGx7U7oqT2LbKI3FpZWpZ+2uv4iEaK 86R9ZvVGHgMWHMPVImghv48NYJcs4yeUO7LKg6k40cIcxfQ82EFU14iHTnAp+o7mIeWmCXbZ GBEOuPhHxvoDMzQwbJQk/zdwaARjwpWREiaqP0kZna+g916PQ8YfzXKa/IOkTuBkG3SgNm5+ x/1lqunEJEHdte67uyKSJtO/ypR67Df+udMsXv2QxL0ieWspsgZ0y3eN9K9/LGglvAilQBa6 ruXYvA3MxfCnjlSqw3Mj8EHVDXvCyeju9GYxIsNnAemPRHe4xqaHAtRU8fWv1JyA66NlI1HW wbdUgV6q67StB0Pb22eC6LDXVqFUsM93LJRbnHYLmCLqLLgBNdp4SgjvnmtSyT1lFzDEh/KL rJ9wRvBjbciWWvCCkVcYLSDjQ8wejGljnDGRe3KJ8Q4eAg53NplsbCala09t/oMDPlgYN/rp WbbQNs22qfAsWnifs6RskaSxbOd6CBnLZujBqsuU96CHfXPKwMI2v4+Xpo3XIsduGnPuTuYe HIX9YUpQJB5nYgnvn4LI893yezPglCSknOlS1JDJ+OG9e3qyWp0axH7g8EiTvVvuRHESKzQ2 WXNRBDiAUGCcDvj8KasBhjuPv8FfobWM5c77cd+NhcqXvwrF6zvTQAMTWJT7VcxZqIZOaLs4 HMP9xzyVVr1Tniu5eZojGdCn3TYutfofexVqLyIfoJBsy6HtFyWKVRoyZ4iFQU/pLE3tSmFs SYGJCvzLSvu5OcRWJy8Lb+JdtfmOv1aHGmq4LBxBQy4w3yhmc2qpBhQNpKTX64TLl4aTaGSs jx8KyjCwC+tEhTv90I2uWBEnIyIZK/UTuji2jNv7SiKu7YaDvh6UTemt5lxq6I7/d35qeo11 qX1dBI9ctcPbPaLgPHPiFNGaYPkuy1KKdVGqGaWz3dy/skbw8vUQdqIHue4WlwC3nPfKhE56 9YsKRRdDn0x1jc/zdU7qhmTsav5SY3iOrTcIqYUz9mGKGXBuwYsT7lzz+ABQyLTDAvul/Cek oGBnSVxEPoRNLrkr/Tdb9xNUJFG8KZzdkok50X8BC8HIoPI+veOTJSJQ4f8jG8G896NrhrOO Ii/7sn+4BmYoQ188y59nmzTWBsZmvODbOPLJSkztNqqCnNEDfsbNa1ylR0V/PMcE7bOJop4R wyAEfOkF6P/pmNhDnM+GC8fmDu6J9hFVcc00gPeMOISHoVaXQkIfI30jCNSi/vMmnxivE5zF G+Vq57pz/QT0AyZWYvUgyN+0cEGYbjJ/kXqIdM1jiQoTI8T4M9zm4bHpAVk03B3SPTCyZLre em8O5WUh5DAgX5fNONfcg2gUlfp9T5Wg9TgfHN10ARdnOTaMO0f4ruTh6UPL5ZIbMhfhkZV8 aR6oFbARlKn3uWP2yFh2jXADwdI6KrMNVwku8gL2iBLntlDKikUML7BMJXgrRecFUwSWwvKq IMlWUtphITT2VTwLz7U/m+Fo/Ulz+k7yWUYh3AqqlqLtkthVwZ3eWd70+s+g7TU6oGUpee/b amgnugXKc5CWTA75/MDnlK+/lnZz5JU/2lv9WDF+iuBmobVv7dvDRgH7SdbteCyxC6u7OsKH X/ANxQOClc76yQ4ILNghANqHI8e4o+mVAQO/I0omiGM1kdGnps1+KVlAi/oEaQsemhO3DkA2 ru1OXSSxGTSGl0G01CBExMgS1xVIUJbjL57+zVJekufKQyzWWNbTB/TSyo14xgWeMeTioMlu MZrbsQDW+aWXsMo64tXP5yqBqhMY9dp7M8lDVR5xf9Pj7PmLNqkZdOYN7mb1GoAx1pKnqvrM 9AOozEb7DbgddBWMhn7C1NNkNADklrM8pEa56PH6mylQygp8KdLwt2gwbC1S08mLzOiZ2/n2 jwmsjtxFQgmSToW52nj4n6jzPxFuaN2QkVAV8LNjJv8Hfw8t2pOkTWCsb8AbKAgefmOhNE4E QwCZQYzA9+4CP4E/04d+q7S9sdX0uraBBaTwer893AwieR92C+OleLzU4fcoYrNmoSsC2Is8 Qjy7WdIS/ipG8Vji5HoCAvKKDYH0Tq1Q/CLJ2VqqG40xBiQbboTXv1FBLXZAo1k3ebJe1wan BWrA88qKsNTZIJuPlk32I2hlcX6gH90F60lQvn104XFmIpA4Ze3F0N8Oz9eXprVeRu8mdA2G Rwp59ErgV98oFTZca4Vied145G6/jE3+8RE+i+qoTP8kn8YmQQc+obnPrNV+hjtWgFuMBw/i +fFXhzIgHMwAIB+IZES8TE7Dta4+8WlYYEpELYV4ZwluNLzqD2PVlWa33R7tqTDpiSgk5gyO fp3eonYDi61L2qwYrudl/jiHK9Z9otbXoZe1J4noQ7h/HCpOadlGipvxEsCtCg4jyHrMRVvT ZS98qZHzVHh7Pge5Ey2/CDOmxc/HGJS1n8h0qH9VAeoerMMyXDcOIS3CTOclripnI6YgP8cV JpM9fc3RhzeM3W4dH9EI+r95Ot61qBX8YXyOEfquuzTbHjk+g49LI3qMGM5VtGo3wiJmILeJ gmhDtAMRwdApucm92HyA8OFQf5FWL9Bakdre5atWPzVnlsuYiWPw/USYAcf2Kdz+s2jE7VI8 mHYLvhkqajs0skH2dqfdL8hSm7xELQlBs5sFM6pYriSrO2RzEB7TEuldrgp2FqoD9RzCKDK7 avmfu0dJwbSqfGDy0SxcTQjYDgKo9Kmr0MSh4gyeb+mI2cHhmD0eAWbj8pZxuJx3ZL7FcxuX itajYX0IBZIZ/6BjuWKrVKGzG9q/mqIStL/Its9Eaoq+EQcgJq/DJMNZ13Y1qBY19Tan6i3P n3NBj+Dlocq1DDYS3v47TDKkLpBm4a1WCcYXf2HB7FzOFYte1C4YYkTq5jYHI9xh61L5R2xj 8ARZWLNET0Kf4LY7Zqj7RSkMIoTUrEOt0fA+jeHqof50NpjxDiub7t5ahKyTRu2mn+/U0ciy 6C6psi+moJ2Em8ADcpopChiLTdFdl713jo68N8MdmmQEplZAdHYDZfwYo5HDRsxq51Ua7Ct/ O22Pcrny9YWLENs1hgk0aibOGvG5SxapC7XJlMrUPMKQUBudMPdiAvqCcL7IQtvagm1CHg3L zX1XMVAof0EwD3XN/nG/4MNmXktN4IFXfOcbzzSoyqe5FLhacUhulP0C4FqvMD9J7fiHozvG fvEgRgkqRgckqgH9fz/lBzyL867qOFRT3wzgJNhla5ptLj9vMum08rpYlvHdGV1H4+HGoCVK dfCLGo/1wO6gpt3aun2Qqi3WRyfEpvF1Wm/Hfk/3qDiDjG8qGW0ENUlEQubwI0zwHznCN3FO Mj1Pbd5NcVwn64FJXXKZv7eJK29gIHqaueXi2Pib72Y6vp8cD+tz4jDJOqcU2Ei0YXLEg/MM OnJ72HUsi5xsx9S589tEaNZNkXXJsZzSUybjVFK5zoV4xxkIy+8ETSgRPIYwgsi1YLhwJyjG eFxG3+DmR+ocDt8zyC0oa53bqfxnaF/HU6g6BXotJb2QS+GupXn2XftBTPg+4KT0zrqpd2cY jZ1eBek3WfI4GlaosqS0nECWVesRU8pMRImrIKx6fpCOrgcecPxJryQt76NY8zZzU7PW8PgI mda/rdr7LV4QtBpPtZnui18vz+TlB+SMatuZx5H6JOn1u2DDjVYWD9pyD8nIYH1gC32yixYF IkskBNPjEB6IY/t9B8f79LEeIf+obyY8hQh2AMg5LqOLbLDaxOVD+Eiojf3YqLZvCvsNEDgu DeSzP3eR6rg6Zbspuy1ReW6Fg3aL0rWevtgo/6ungV+ZOpPmCZWoMIB4zLZ7a5NNTT0isl5J mpl9UKnf5YD+4pj4oGSTCvDog4wcORtqMDi9li+hOq1XdZrTlUpafQ3PMG8SuD5sughDhUrQ 1cK0Za+fvfSdRZ2ehtEAmCXpIsVc6OiYrPmA5YgF2t7m2LGdq4vJz0dVUnzNGpz3qSgmpuO2 Hs1W0YDUldVo7WIvpwF8xu+ZSoVcbm2fiQY9mCp9qEEZNMQX0fgNCOeY6rGSeiAPPoC9IiT/ KOBV8iqe+WrjY951mNqOy1HyAdMKqi7z0rt1UNq3Mc87XOZVVZOWv9BgZXMQ1FaJu1O0q9Fq uMNxmVcU71ilFiXh1k/3BIUiVsTI+Sgc5wNEuY0q5qVVw7776Rip3ZsGxYWmSLiSQLTVY6xO MQANy0H74v+HAwNvh0CeqZA7A1dZcaiiYHJ1LDrrpWQc4CsXQet5t5zcupYS51VUdqamvmfU 3JY1w9KbETRaPkbZJOKgx1p2q9HRf0jMZ09oEsnW4lpSFE68hYbeUnBlLx4QmFmOY9YWPCnq I04oY4AXth2zeLbYrqFwrTO2oaJBWbqh8pi7BdsamZDALtzzFMxTvXe93F4BbzQD3++0Mdpc ztDBRbqBLen/7OdMM3K6tMSnrRzmekszQt3OP/1U1JJ2ic345FeGkztpLiV+LH+9Uffrofy8 YDSGXdKWhm18MG25+U+X4TAS5sCZROV/P0jAlSQTVTr3Z4zIjV537+2wmJ7a/KvY3xZ6Tajz tEsiev6n3V6PtVQ0PaIEKhpXN8WK1zSynOMDcGednAGbo0YH/ZL9keC5T2Ull3fs9WauerGU PKgHsTFqks8ZwTgH/xH8mgGKuaJJUSy8N1s43b/wWO27IdZNBW6G9lpAy+sTv/Fyk0JMBLml p7JXuEHnzwxl85KvuH8I3e0AtZYv6IYjyP8bwaD7vGafmd81g2/mwCw0uc8W/hQf1oKqlt0f JjU3PESYMeVe5otNU3YiH25XqkHMLEPlAqisbSnbN/VE2FQGv0Q2U4cXNRSr/5uN8N71lozA /VXNXdurWpRWEGMGH9B5hmk+Yvahvyu/72L1SpvFVmdfJcJh51i4uLD+fmXXCe6nrVz/EHpb JRd1mWeE3wBRzgtSwmOcXawST5fbOPooHlsQhjTjnh5D4yMD3rPqu1PtI90A49S3i5nZOWpU EkAVnn7EQx6sZpGe/fOSRjEvWIlQrwaNNbwDOux4HRDyzfv/RIAGfbw2wtVA4c9FkZlhpWWZ Ycz7w/lI9EeRat9ZdcLHjsS/T1c0aWlZTb8NLCrIFZmJmG5nxpkh7BZb0ojFb48BLxLL/rjt W0jzHE3c+2FSbteLq331ThhErAqRhvdgI52XL/FWdsQvmeKOSMb8lyQPh2uQtPyZ7DFbNTbE VAldq+vSr3SQTPbIQlSRkm4X9+wRgXvSLnS85gexVWQiSFz9NfglpvkFtrPCqmq2q5I/h8gz W/8+iq3HUnc2owYgpyFOVtEUf6K8Qxnwgz2DZnVAizbCKBKiX+a27hRpKNRFnllqylhuPl99 WOfuGUMPy1HPqf3i6JwT0u7UT13s24mktAvxaGHhcdcejyPcmpMlEPa/N1Ctan4fi/S9cDtn 13rPLhSIrq2zf0r4zH65FF/Z+bQrrmb0QrX2Dup1+1flkuVh8VT3gH6m9VnuNeDDCtuNzROc lSXrd4pe5TqVmUL6pr4VM4gGEgyE2VFt7Bk2CIxwVZghIcVPOYsY3m1ycNiNTq700/kt0mwI 9kaHpUfrBPwU/UEeiRkqNs1elqLpJX5dJKk7tFxR0RvS6fC04YX0xxHx74nznMXr2hXTVrlo Tly8VMaj8DCFExYPo+ShVNnofqaSDcH8FSb/KGQF9AQ3GFGBQ/MdduYfylJivS8Zz2v8PLvo 8FMzWemJS8GgEsg8KvMyKswKd8X1jRX3bC5h1fHbc+jVxETASD/Z7zHx9p3OtkkuRG7vT6aL MLWqxBuIqw3kjQFi/0omYkF1fAHoRH/Unin2w/VDITQDY1ZGmfq4FD8bEhXuXzZx5wE3hlha aUoiNcWaEgwqICQn5/vb96MFl8rEQnmAjqRuaDlP0XQBdd5o3/l1Ob92vNdmvyxmJby/TzlF W/qfqHoK9OqDPvy8UAIBMJQ3fF/oX/cv1jOhGB2uaXMaXTv0Fx1DKQHzpmS6aYdT6UqhYZ43 ERfIZutjfzJLipjBIbH7qaQW351oIk6PH/YZ1eGXahgrrrCnuM+fYVe1pLmwlAehF5bYEmZS hHJqjzgZj/67DurDvOAGPzzLtiaWgUmzbHi9LDsYHdCoglA0ql8ZoBJLkaPwJ+SKpl5EQ6bc DaERqTDpU7gG9nXVS8xjCOcWmEjvJxQysbmXwdOoYgL5vEZ/mpzXnKpwQUFmXaavO1k012N2 LIxcrDnMt5/kybHn8O2gbExvwsKjpQkQIOfv/dQ7Un8OwBLXmfU/kQfhNgGnHJZyQVkJpJhr zYTbmH4/zxIAH4LmuI4mzz2FpcZUyzohcn5Z6jl+UOMWZfpH1UDmKWchsxv6A5qpaLXNG3CP Of/G9k0ew4uaRbozsjJb/wf5EZhw1T99mHj/chTRnJ5lhMg2eRnivpLnVETXjqxaqrCvJzLB gfMNFx2uNxLfyn+8MFpwaqvCT9pUpk9jIZsEUiMutDd40kdm9rcZaE8HIOoTTTTJdO8RgpAd LYyqmX4o9X3/0SSWVfQrI9JWEqmrb18AC6jk+g7S3mPJxC6yqiby9GHTxWJ3k4t1kW6dkrhz +Mcl8S+hiZkOWSXTTWV5nc6mxujXQYXZ6PmKrQjCyx1AgDIxH+Gy3jdqctaUyi0/LVFb1Eqc iu5SOkY5E7oSY9Q1cCL3L/PyYiRGFo7dUb8+UliJ0MJmkq/T28kd5TBqUVXvhrmGeq1pOKwH xh5hjcwxWRX9BPTvK4A8qSbqm4n3iChmE2mXvLl8IGW54RlHLggGUoMzh1gY/buxG3a0F8kE u6bXXak8TgwP2m/wwl9TSb7kWbMjxtRZD4cOYnO4W95r0c48qheNE+0QL5a37VbojkPyaXKZ Q1qIoKjCFygtM66W21cNj75kW1TJuYVfImbOu90WBnOazlbUGP1Dm4MjIzcb8uTyZBB5Bx1Z 0iKk1xP/7v013c2a0Sr5uYGPtgHfQGEbyBg/e/RyUKScWAbWBLNDeKBT80aZvLSRhTLvKY/G I7EpqfQtnLeSD11RFCBGxELRRp7WKB8DI4dDMYx9aWARMm8bXPPMNzQpiz52AGCMfNhsj67y IssR5oaHr7URLYtEtKUiGyCWHmyY7KEdbYX7FnJ7t/sXLuyIyLuPoZJcHbBFjuOFybc8Nsdp VgPk3+VtJpvZoqjuGnL8jPUJowF9Pi+zW4XMbQcHl+ZDjzItCcTyeNjfgzGiG9M5ci9cC9jM KiWbWgOvvEcsi+qx2Trl/Ul0Q7s2ob9WqBs7WQ3gXmLR6sXuHaPezlCLR9NV9DhsqxZcFFqB pzN0daeqCSAmQGFLKbDFqEGoR31T0FBtgQNAhoW8E7v3VIJsHAfkpC/Bo3IUgLLR/Cx6x+zc VddrgmszafEuVsLDIU/ktxM336hxQPlqxDBxFP/wQWu9/dwykIf4YNQ7mPMh7NUlUODtPFLz XnCvi9T3ChMkd7byPOv1z8cXUnSeFRx/rpZw2vXkShzGDeqDK/dVeqVc0RDMBNVL3pRgNpaq qGQ+nwQ3uHHAjS7LZ7GjAxFQW6mi7LZVVnNdqQ4a+KcheLiDnN0th6nNeSPp2BSprox6WRBB 8tsw2K09j/IA+JWPDRNFKlF4ENKGsnp7HL6OPn3QUkiJvBhGbvcHz8sA6LidXmn+/ASnXlAO IwAG1x8NVJORtuPeiAdQbIVDTHIyGcrAaWv2Le0LjHo44hU4442PJ5IIp4tl85Hb57rW0imB RfUReWgYntj2v+u8cnaVnRLfoOOG+bqwyDxDYxEbuXrVmBwDrlTGuXudsHMQT8uxPZ7CTbgL gAIL4JFji8LWPI84uPzIRA18aDhQaZZLrW/edQfb6KbLJIF+TPdgY8gWNia6us5w0736Avo7 nAF4I6/tHtqlnx0A+nkHI8MgCBORWbPq38PhvYOYtajOoKR0T9QZX8piwfmNm9wnSg/G2ZrB sPWVlybOPqQNZ6J42nis+UHTAsrWR1bbkq3yd1Ha4GR8nlZO5N2QqT7hkZ74v+uW4/pPugvW D/qdeHJFxHijvpuvUx1onsuAGpR4hoNzUXwh3tbjFTruHueO1wrhY8y0O1CblayxpjlbshrP Ab/mQ7xda7CtmA9QHZkAtlQl0fW9662PeYFZOFq2uJfSMm6qITiBrpGeVdsgUvsPg178mZ+X CH9luncbdEmuw0QqBKfmTZg+VFw750ZkfHZohZjEVWeeFDt1JMbUCnk5ZjrLF+C7ywZQda3b pajcIHqzZm/N8vXnIdeVJ2H5ZUh0wZrZJD/oL5KwdaQtPcmnPksv21wQuSX/bpfZ/3vKXTkq VjDmsBwaUxwx+uC/r8gfNlXkIw2J/4qfA9KVzeBfVDPXfP0fvLgtXYCusfktrOqgYSRKyjr2 B2EexWYLNtws3lINJ86YvIQFM0frHhGC72fm+rTj/NXOEy8rxiSj0Oz6dbpZuTtFmddWqA/C VjrH7WP3UYeSKCz2ZpBQKptLSO1vW2zk63oQsJOviN1iI9f0wpgFy2d2HyUPrzLV6I3SlsoE /iZ2draKuqGEM/7WGKdwVJBHfB4LdNMnorcY6Vxn8H1gJbG7nLu1rS5iyVHCI6FwaHcrEwmi fvzqfMVzL5pJ0rculElcTA0TGvcPbe3hPOJ7AubcbtLLpajrCnVLc7s/EoTkPO8wzwqFLtIj hrd81UWhZo9YM+nHwQ1ZnjTOOlM5HemL14FqSssQ4YhJx5WGtRekABecWm/tiDmstDPiPuWc eIkS0BNoDfFp/FjGMCx4HOJ7ljhjmdlUHWqXf/PncbaJT5tgaXKM5fPKAeHmHYwknwXw21be NYX8pvtVltVI2ri1+XaBW+jEkQLUAK/cwCf6MwNiWhMdiseP7CVOM+w4lO10VvbadkJWn/sS m4kxl0RjvJBgw0SU2LXey0JFz7AOR2QD6Ora6FxdUkm7sUqb57PRholfOJwo0GfakwQkiHxV khyAmNs6mkl5cM8X42xZX549RgsqGcBS5q0iaKtzqcl2Sa0qdWf9AHPD6t1A4bnnABGEoi5H 8BwqlZ3fmCdUTpkY07LeMBwLGpNUnHlh4O78uk+aOPIkg7szeIXFPT/zQeM+QeVE8ay9Dn+g 5ercHK845cGAK4shgqR+tvRkQAOGYkbG+yLOpjkav3RyKoBR3YX1UOuzx2haUHnNeWK5cUYh Km4BFaenYKSl8V4JbGs7OUJcM9+jJwpf9Bb6Ku3SCnVgslDGRAfdeUwIU6r50zN0+hRO6WYO hhz9F9aLayvKE2M0O63cqUg8PPTEXHqkMQPmZiXhQzhGxwER1jMevpRSzJlTSzVO9Ya7Ptdt D0tSbKgFH+EtCi6U9Xkhq3URNUZytmT+ehJ8WLkJLLAk+5x5U/2yLVIdO+OJ57ZDL914jq6E OUxHDgGbi28aIzdO9AAkkqKfinh4sSxTNkyGeJWpy66agX7W1qcSJJtUI+FYE0lMhQbe2K/F FISh6XljtyS02TIln/zaUAMhMGTW2zNFxNLAhAbYs95I9P5iZT9hpUCVcWte1mqfcYACRmz+ g9LtIV4UfaHSqnGUd60+ivx06LTVhYgSYf8inbI7CLNc6vqNqwVFleE3Jl7ZKT6UJCdzGpjZ LdhokciifVbSULlB1OjZhwpqS6a4H8R9d0w93A1uH3fzUaVqIx8Qmv70H+sSFCL5GjOmTrSy 3m32tqw7icuoudVAuBj7LwUHffhjKTiSxdvWbuSD0qW9Db3q1pqCdwEvoRGY+CsH5Ow0fFtz 4y56nPqcncLRFXR6SqZaJT2oj1heZpo+ddbuBfm60icgIOb/XrHAgFe21uqYNUWgnOi3rDO+ h8d935xhI5UWHnI5LLvEPUQfBsfhHkrOdcpYeQhUGcclRZmv+aAJbKAJNhSqSjxypCMXkJpL y1Ez6E3cT40MnP4CtBF2WrjQZbL0MVYjTloHQy55cHh5OSF2s1HcA/Y4QbvdsrqFiPByBJ4W jLVC4BPlTsRBn4/P+UC2Jj1mzrwF9Cv7etb0lgdDzWzkwKqaKmiOq7+ryBWr3t3YZSpgb1WZ DhQZNS7zIZaycp0UKsbhP34eSssQmYiH1rtAUzWPKTpyEDl+1U+6mVgRl9urUnz9wJlKedDt rhNrdb4uanFxK0XlLtyF3KFgoEwQzk50URQW+76dwJiYD2HcbLB0zRYXo5nFH6Oyp0uyiUAa NvFFPzwUdmj5PHZ07TfzOJcXNWYh4zRWZln+xfeh9dZcHm2rKEL9CNJZMBqlN0GJIUOO9AQv NH4/pppTVZvzLOoRRlg/N5TwKvqMpRVRCM3vAAs3sq7MJOZVAoC+9H7N0Zd091d/WNov88uL DxKjg9HSv0JnLdDiPRaCYNO6AggwELJUtmACkC8/tOG/py20NmkvTJd/knp+yvu3e6wpdHTP 64Q5XRLP0m/BWp79/A00aHb4EYbnJByEcjtCWhXfHFW19Ld++nlx19fgFJ0tS5SHs754hFm8 IirUSmW1gIdpowyDKx4GfbgGmKBElEswWEZr0htez/ivlmDDkM+a/Wf3YQDnk+n3RtzUccad /iJzG4Oa+zxdUUH6n//7IzUA5bEwzChwFqoneibreSjtqZ7hxruFI3pAUcr6yCQPD7mi4dnU zqHw+HMevZh+WNo07zFcn0Fzc3lXuFdQAYPEgvGG0KZ/u+c11mH6HLPellSKDx4+Urbija2j fJphxnGAy0lAf1eUcCG8frbucvXvbc4gNTDJUITe4f6+h69MhK1Zgg6qo4PJth+JQGTKXv6I 4RY0VFA6BHCbozWz4hNBfG9kRLOh5W4HdipGOjNM7gKK3G84BVGfsrk75UIzzC4A6oIbHZiy pW/hRog8XU5uDtdYRQ6z/bK88XCSC2m8Z+uC/O+uWFabkpGaQmcmlm93uk4qWg296vU2SiRL aa4zmawRc9+OEJ6ACD5FZD8GYdF5Cahr2x8cYao2kdSyJ0Ggy4vT489hQMKzzxX+8Dgw801u w3YCORu8cI+MgHEHEVuj6IrAS3uufgHtaTczmff0khxRaX0OhLtkIXa4DEBl66tcXN5nIQIX N3/7oDOmGU42fXV8XrtPOVExQnlwZP9qEWJJeFrebPbh27LfjyAXB0U+DNOdF2chuU2BU4oq gRanr9XWPdt7LW5nZFhQ2JIEIqwb6s4/stnsqa8pKQaQlgGCZBZug37Gez7sHJGILZJI4DLu BILA9fezaxOiuH6iPG5OD70inxt31csadI7A/xjE5HBkXR2Qst0lBtS7WciPqWiz1Ss7ZfM5 A8ecRTM5UxZpUIpYXTGUiKwX8UpT/z5Wvp0UvOe9V6bFcNoCABaO4YojkGrqPDjk+coPasLn mmr7ZQreVCbXBiPA9fbwLhQ5AD7oA0zbJTfhVHKWIiZYsmu22KI9sOINtqzArGbK2PaIXvOG JDlD8vXcuzHJUp1OpVfcxeGDFuGl53toZPv737fL63LIqtmuxS7sorJD35Z1au5sJvmerlUp dkZXxd9n4V8DqlOu+GkDZDK7eLD7d2zetx9kIAK8i1c7/47z9US6gKQ+oikItxsdlfcKaAgh F8jJet2HCbo115hpcBUQHMzDqUO3k9XDyDvgjo5S3V1EfRpaM7+ZmThDIRn5DHBJWRdXbyoU vSiXLNXRm35ndgNuIYoRG37ntSy2eGtu7+Ja1NKwufxB39mPVTHUWDbHbhLQ1NEVctZfHsVK FES8IqjlFw3ED4Qu80VY0GQRRZ3mXC4et/25RSufBXfsIqA6xVm3HbbKnVxfylchQR0u0/u8 8mWB1xjmP1K14Nw9sOWM0NrYYwwIBJjl1PdkKGoPVh7/WmYxFE9nyfeah7otq8Jf/4mIoax+ /eqYno4TlSt37jyF3oCCYEDKQd047CBXqGfnZjyBG44Ex9KG6q2LyT/1zDW2WcOqWY4Q/Gz3 DyEb68RMkhb3Mxck332O4OhfFBW6GrpsraGgvz8IRKCMpafkqwiuUO0sKrS/2QzR2EHBRF+M 8OAH0ewtW/b1hrZ3GugdIhWRtpPxvlOU66W57DBH1iWEzPeZFrh+CVlYJtpibEL6XjROmeMt Tbg23i8hwcdrh27uI6zmNwNpPn+w5z01jS5hrI1ehA8UBLLYuo+dIacnBBOMCYX1/W8gg0Bf IK9b3MCR3FF7bq0s67FuCpX0leRaq4Y2K2jTJXX0gITZRLcnax9YNBwr4MxshUr8ZbG2q7mC oVrzOF/IQHIUvqORxguEuPnUEEtpsqqT1N/LBRZbd9LnoQ/RUyR164fOiAAVzgLzE2xW8Uwu /D/KlinRMolGWMWrrSGnZR88NZlNfdVoVhFfiGKW1LFktzHmaD7bew2QWP132hYDKjo80xmI wFQRmKRw0dso3FuorCfhCs+AWVEMz3gUB8Ya/nVcSNNnAzzl6MXn6UwLA7kn0NV/OWJr1+nk fHIx+4Zhv4lausLLAc1d5s+5cxIwsXhBAarUAAlEbBMKy3Z6EQTdJucOX20F9e+sf2sIvWOd YZZwGILVMf8CB0abeSoZMCg0KT40VMBIGljoqZoNqLOOdk93PohwMDfD0CnLGQEiMU6zf8vX FFd3iTLj3z5NJIJ+elB+XyJaPNnNRr154064eNjCzMh/+rDCOQLaVsiwqzSDfsxFGxhJsekc nNTX9RROEq9IWOeyNBDb1B7n+asAiKjTPEcALxcrKoACzpaE/MehYrbFCXGmlUzbzHXW27NN YtUXT7jkmKPvJ4NfoyuID2mkDzENNyIYk3YWGe77MNy7zKTrNwiC1VhtMviSR7VgTN+EW3eE /bkF11Y/YuXNaH/aDPM8gdkCxXt1ffx0+idVS4vA+zDdCusbTNoI4VsvWQl8JOCvXF5QyPbN tuShkKKOX1cvvU2qZDPi8PIhb1KE5TOGcwNGfR7pIZUvFJm9o32v2OhQEG8oyU9J05ylU/2a +UiPiwZIP3hGRSXI9sggYXyOi4Ml1HYmN2ed8WJiOzz2RLRn1ppBNlUcXac2NykRzhhD6t+g kPoaKVg0ww2k6vZm0Uh8iEnqFjfG3Kv4alGzDpRc/3ob4L2JP1vrzMzYeSkFqFVq7XkqHvdM bbuMx++hd8CdhmGmtmB09vRapK8eZSYLcY9O9QmPMWtFsKuVHAVBZZVXI8neK3YupyUFv0J+ ifrSLFyX5/J038thG9mVJUDmPb1G4LcMnAJ5kFrnfF0yKMDktySGSzCrJ3glhm8HREe17bEq 4kj1jCa84+/SVleMd9oVpdkSbf0slztvJIy9PcxvJOaHgmSZxGQYatyoZZft4xdhm8OWGCsO mNSPsD0iElLQ7QGFoql7EQxax1p52Nh0ZE1mvy+5CkIeMK3BEOhEL45dIwRQQy0HDuetzg6+ oyHj2oe69HPY+JrCn/RbhaX1mTBRwDQyJkrEHBpGOpJTjzVyYOdsHfpapKLt9pDz7BlN5aNB i4bdoGEuNKWMdrIDQcALALDheBFh8WpHSM23u2okJOW3vdTpTPadyHhgzQl9pNmfv8Xui/fV sLgk5LYhEknDc9yrcfZRIGVyQkPTyW5fmEjDXSvgswJCF0HoB2nU2sdaotvvC3WSvO/yQ0tF NWL8U/apv8QWamBbqIkQ4QNy5Yo3GPmN+IbaaYTvEzl1DF2wThVqfm5A20TwICYn+A3J4K1G Z1WxREvdPWcncMHmuIbcizTdzImLOn00wjOqv+MOJZLOoKJjLyj23pKudiFMIOyoauZnMDyJ x3zlp8QCxGZpM6DmvpE2OsG5WVaC4eUQAi5J1fk4FMhqBsjzcuo57wkMADJj5zGPPGeh+fho LF/57HEsRngJBbDCJHEeRFVvUFP3x+4lThIy/nTl7wUk0o6aeSVXRnWRO34//IqsV+AmxPA0 UK8PK9it/V67v7BDaycdxGFHf+g+irPI2W74TwbRtWmOLLRi0lw5lqWejpdynh+U6yw1oCRz lxcC79Lps0r3XoXYxIle3iJ6pHjFron5OlPZLttPRLIxzOmLye1RIopKgOfr3h+R8FDE7nHa cUEhyf3bEJlF/zZmPCdXnafbQUeswm3XkzeFvTfdILIQQdZWFH3bAJ+KEhqAgPrYq3C0T7Tg FKmZh7GTFBB5fsFlPW1liaoTdxxCd680REqBOmf9JRy9x4H9B38z2mnQRgb6GsYV1ZdkyeQu aV5YqPhG7E9a8jm/OPq8Jmy/jwpwDSqV6GSZW7AyIdX521ixZ3NLq2KhzOZMumcxp7/XD0kW td6IWZvyQPOwDzFWJ3pQYpD0lbNxb2/65ApeUYBRC+Um6+2+s2tWGIw1RL12HA9w4NnX5Iha K1yW6OUTef5wOecaxufHqJwxf21BEpap+9jPJtPYkDxqp4yiRv1O9wSZhO/D3gaQZYPg9bNa fzZO3oQSPSE7HR8cUmvija9X72rvxIJpLrqnFuxmXXO96oZ5YatdR7y0YTTVuHddQJa6I0+s UdEXllrmrbcjs77Qmg5c6L2jhYGsAGYalj4IbpHgTXViP9pyc+26M/j3sCczCdRyyT5fdpOo iqGP3I6wLAg3v4lQKRINoykr4kE8+KBp93JW8XnJqatpRJBZm/dGve9NhIUK32abJoOs61v8 Q+KZ30ZjELfCkY9E7lkbjo5ORXip5lYTKIIF9PKh040VvesPkSQbtjQhRXh21uEbxrcVf48C egx3R0uGExN7+fhMtXAYXBnSylu1SwU8gyOTnpFPGQRS1Qf/HdfMje6dff/5UQ5GcDdmLSzp y1Mkv4xhkSQzsxhSUu+O+ffUWOaxEeJ+IsZdsRuLCF6GQow89Q0efUfEkiPmaZhn/+l6dJzX pzKuahSrub62o6021dfSeahIVl2qxJoSfQqtxVQeeiDS/biqWCUscPFsG0Xs8H2RvE05trML VfuQDlep3X6cu/PLlLWpwyA68wkwGtCTV1x1iOAiw84Jj0KXLqEe0p9qe9y9nh4joqhrw54R uHKQKjFvdRoknafGs1Yn2Jv+4A6egRNrZifXoPHOz5UF78RwIdFJZXuxbrTBkrsn8w2QtlRF KEzYnKrGVAteIhbL6X7SQ/D840Icae3mGobYga6xszB1i5oMfXTt/sG+cz7cQRX4W+T0RmpB wKjP/QBYGltz9YgN33oj+0jyOyQ9Z81zwNNLT4SUIjBqxjBEhOmFN/0TXn3Q77cg0qV0e2Pw PCDkjduA3QU4uWmRW6pPlD3i14QiCcR7xpHRfptnMN8iogDCSLYUXcWo/zi2NLRruK238ITe U0Lk3froGEhKTAY9LS3kKDPOImix6Du9gULeuf4LjQ2YQ4LviTulOM2es54tg/itQHbk2Sep 4Bpj4KbqgnCTwsTTFA8mkTmAir6Qhdkj4+wtHKe2dgfJhp1CVAjHcLnvwcxxs3eAQRWLC1Sf ck+ttb2XGF1lEjwSPFT1RLxmjEXaqMA3YYSnoERUCot6RYHB1NfAQeikkybUmFD2YvaCVn6U HxDTC2EDxif7RRB7Nd3hfwtzrDXD0rUMoB19e5nEV3KQPSylX5Aww5b5uOIGzuV92n5O0de7 /bnbAd2ensJcYR/ALXZIXIGZhKQt/qkB5DJYQcuwv4IYcQNVOYTmhuQYjkoD7Y9V9tVJInkz Uie+eG8niohX1k/sjFCQjFg/7VginWQxXk0bF8C73S4ZzfwaBhZJ98qr/0NVLG/iq/n+/rSB B2C8mwBOIWyiMbfXvt+tBRpo8f1pSwKn9NK0pYj8qexK+fa/QTEaOfDuNuETaNMocwBfzur4 YyOlCtAXcm2BCq1VhH5iQHVnoB+oHl19ZYdCyJGct7KShZvLzpN/ymPEvYFJoujwyn2mkhQH 1qB+H+PTyzzXokzBomnIXaXAQ0iphp/Ytu+ZiDAaljql3uqH1R1Ku/7w4PDozYwOOt1NKWRw 4M/Zt+ytxbb63B6DY8FxNTBOnJDFOj4czoN0Uc5SsYW/MRVD+4ocjg/rOk6rN1eXtzbv5pK/ 6/wp793151FVAeUUDNI0JhqJA0qx1ypwjWZijlH8ZrsjDKe0gJGdnkkW3oD8B6G+lttkHxf6 RkLIvjoz8QFVfuxiRLTY4Wy9TDR1UvJU/CpdcOVFJuwGRd32aowgS3iUY+eUCQ34ViDZ1zAg C+v4mYfVeeq7Z341KEZ193++SpcpTeEW3X38e18DYswoPwn4sVQWqJfoTZvgnqMpqKktOaJo JHHD/f1tkvFbMymp81Iv+XafvKcSt7qgVMH1ERBXgrLvtE7xPDgHQPpVRv0IwweczhAlDSCN 8+TlEJM9D5oWCHrczDGuKr8AYuw3668cU87RSBo2thOBvPAERooNYtNPTQuy8+/gSZp//iJG 1ZCHL+WGP4hZIBatgpK5vEOjMUpslM+zDTXEdn2qhsad+43mA4fpOXN/ARzu2MIFPu0X3SPi bHiwKRADzKcuoqXVX14w2iZ2r1pYzjCe74cXq4tiJwmhChdV+Z00+3stiQvHLOB+MXyeDtlI mUjhioa+8U+++BhdK9qk8igdbr79bPTl0PztZc4KCUXxmEVGuAMuOuLGGFDsc0notM/e3nv/ trxIRLF/JT4/SUubSgCNVpbs2cqs5BEDvdNehvvI/rR+R499Jxugg03ZWSPtoC2ucJT+Mpd3 buEndt9k6N55ZDRgkob1grfn6rPivclitgnkCFM7yn8WsLMeggid2PmczdCnPYFfPihcFYe8 g/WaMgHpMviKeLQdL5Q4BPsBqdIV1PdIy5PiOQS1PcaY+K7FQoYQYcVViOlJnILSp1Ks1pJS lMe8z9l2BZni3O4tmwX7ME99ZSfUXEsq6DkEa00T2sApAcLPy8G+qeGQLJQ9vt3PbM/Q8L8W GKmecc9nGj/z/HDR8U4LXbBhqIw6Fl8FVKuutCmndcAooH7qOFBrHlWObRzmHKPwHGdczpWK CS7p8701RJJ5s+ohDLrKEytd9GzEqFoMys0zxHAzH9tDdWHkfR8ZPsMLFa/wy6uZomLtrGyE tOTl+qYje83+G3BlZuNtFro+CNXg8PIG+Szc57AV7a4RQxMqKh3qC12n4IluecO4ZOB2VS6R 2XFbUFA4fWy/Qr5rpZRPywdv4eLSjTbOU32jYaNm2voX7Vy3hlWrHxfEBWzY8kVD2vJtZB6I TgPF1d4RBcF6qP0k5c3JckI182FAu98jz1Z0FUeAvjFDHouXLII9xFjsrpPe7mDberYIDvWa 1g9dZMfb9I4xKjtRqdTTbNkKGhqr52kCAQVxyQbtOJRp2X2TfuHJ3muZDy9EYPELN4qUu1IA 26QR9mkh/O+MLRX3Z/szaTIHP3jdj/21cSmMkJn5WpeYthwArbWn33kkw8Za1dQ4ZGVIBQ/w y40iw4vXTSeDNZljRaG+Rv/4VbSqyQbMfRH/LT955neLxMnAtF7KVfJKN6G02Q4eG+/8JAI6 rU0iBU5U/kYWIUT3sohU7Reu46Ufpa4pVY6p1ZEZ+q69lsa4ideyWbI8vRz6YBk0G8r3tQeU dKS0KsdZOdUFACUSypJ5ompT+FkQHtPX5NraW2KvlUfzPwiPxb1MeZ819HYcGhbE4B+cbqNO 4Bsv5sLsgNezJlmkAv7Am1hBDzRjaMNOAzOraPxO0RCKo99MnWUXf8BID1GXbdZoqMCzGiSm 30keM9Q5tNbVHDtOxTW6bbKURm2p0epFQr6Bj0IYr+V70bDuvizII9FxcsbCUgxJTY96vjFj eUe3Ivib8lvSzG33u/LHUhcoOaNDcQZbYZqrjG/FEJO42/U8kOBm3Ng8csQ6xfOpX2E5vx7I jFAsgGAr7XEIZq+Kj5KW4Vyp5vvWRVlJU9SjP/MVJt2UGIXKxHr7au1m2JOoTLS5yrD9x8tt NkrPuXkQOJbwCSCAYpDyQlnzym1T5PhnbZ2wJn2U1gNZkmTi4DlkJ6lZDtsBP1o6neFagvA3 YHup9D2SoV6rMkmfvGKZqA7SUL9yjjniuWRueQlI8qijPMhqhLReM760sIRp64s+HGp2Cy7O 6SMxfwKRZnL8ljELcpeuhUZbBI4G+s0H3Lnupt+qkKwYD2D/WSxqMoFrR0fabUyDlZWIRGNE isrZ4KFw63C1hdYXDKEI+vYQXvWzDXhIhpkCgIkIPwl6iDD5zLFtMtWF+/Jl9cfwwLbmOhNz 8tNcsbpAkGoT+7756GsfF/dVNYV57KHEey980MgqRywJh4oLyN0Q+T1cyKmXFj6NwWpsC2Wz WYinfaPEt3UhJCMcfkONqxLJSWuH0csK2U0Dg0FAAr0OVZbfIR/oStJvfDqDgpikNi93QCS0 bWhig80h11PqhrHg3REuQ+HABu7gQdT9kyc3Jrz2pu1D23hJhj527yKCzoshjxvyF53OvNHd 2m1YbehBhkuo3CpClLXDoJjk3aZEb8OuSc4kn5aMGnVoOZqycl/X9A4WDdrGvcTPjRs0hrNL /vffqfY9xxTXOmPQgUiKuxtOZEWJXp+iPZfWjJ8znIhSw/nEAHnW760m0C9/IW8DlfwPzO0w VeFAV71Ya8Pb2/pIMBTghnOqdsXOTzGW2+IZA5gIiMf2vC3V9x4CaX1RMWGi2NtRABwL9Xv8 LPq2MhTPXNoP8lFOCULutK/fmoBzF0bhJb3fS7fDuUBQxbCUhYo/AptNEpJMWQR5nYhiiyZJ dq1mpun2i80FdBOBdbf3lt6TBem/+Hz1cre1JHdVbeTTX/YNYVr+BMtFHbfEETWg/m8Jw11m 9rSHncY4M5nB7cVTjDk7hjeNwt/960XvUVVEPk1ce7LCdDQyKtgyIj0/NUV2UnDvF25iP5Vz QG8LxZA3v1VgY5Bfs2dibGzPjrxqhGSQ/bsFf+b7NlH7Hb0uY7QsQy2BEb3+x4KP61rgFeRv 6tNVQTeBcA0+vWQQYPT7zX0Ozbpahh5WBdxEmwWIRjJDMkp/9uXtyxZ2iskzUqOog4TsMHQi U8bW6CEiMyC97D5JusD4u4B3LsU91tzKcfoDLatfJTu+FfPDwHlnSJ8NG/MIgjM9/8OMIdPZ 43qw1tJF5YwbMp51nUQL05ZYeqMqRBLz3fM4siItmgdygSOrWmqI+D6PI1EP3UUQqp1At7Af /dmPvgC2L2AwiumQEoVJIFACFzTZb0CvMq6GdXV1VMyzvyTUKb2HjnIuQu721ZYSLgiavLXn UYCXEz7JfkQl+IGckZZTr1S61UohH8dw4XJ43MyCWsbBXSV2NlirPDNw0oiAkPetKGJC5wOb Lw2YTyQb+TbihpIt3sPdRThc2zvqh1r3Mdtlq7SacZFszBHpVBFy8rGsUE0J45F1fFVaI9mu rdxwCl4cgLhlJJ7WeSjQLH+9JN+Wit6LaM0ug1GHjvvnPF83YHhj77O5IG0rZrL0pupeDkQN bkbZziFHCrYO66GwJLPwOYev/gMp/p6Sgtbs22EEF+WO8UAue7DLvhttjOahJMOFRGc8+Ygi w5Uu9wg1+KOoke7nALkNGkebE7ZEG7ZadvrGuLzh5no5cZ3CVcITLDiVo35yFAh7QkkfNd5v FLEH4Yj9ZJUp6KbvRtnhl1eA657GcEnD0p/IJx2SPweANIvUau0H53HTLMdhHGYqrukzb3Pz LPWe9slBezW6sCeW8V7caqEQBC3Xx4reGiv8yIeO21ad8laoyFBKG1FsEx/u696R/Ad8BUFt g/V2N6bWZxP5C0RPEWpcKn2hXH23wG+StUb1DoMlLABJ80yw10yG/gjYJCJuBrF9JdPSxcly k6TZr2DmFBOtxeXopnYK8mcwntTrjNiIlh5X2Q9JbsoPVVhCNYqGf+VOCEcjdE73pRdtiEOO pO8ktY5XgQBfyQ8qd1KlufCQOCAdj18Gf3r2hN4b/xY0XavX32YTCBK5OkL0WLAQHEaciyZp n5VArsgS3Ov/1swuVhuzcMBKH9kVBOdO3/j1av6OHhdMPFC9Lw4peOIoeaHnqsSULC1DGncK rhhs5KQfslpYDxCA0zWuNd5uPuAUYrtLnWGLhAvmgnwC61OmIGpUOrVppEB3i+FFbcD+t1+U fFJMPBPhQ14VqYsbJxsiCd3qPEbXfv7gLhjq5m2FH2I//CzDEmn2xwzcJ5l5sO0Hyhue93H7 Mi37mLqaNS2bL2hK/Rw+T2mDYEYA3zR61ghgFds7IZz6SepK174LeECochLjr7qX+DhpjeER 8KSgVKejyrqGXDQx/jyb0zc2RNMyqBV46NHjErFZOclhuYVaNFN4AIIJy5f3ZnCIiNQxzz98 ffq6sWP2YPiuNvQW0uHSgg6yhPE6nUGmXCrIKywpWAnDKsCnF6mKA96GZS9MKFhkjB64Z1pg X74k7gDAoIhgn0s34yVqB55FhIrnbPUqKTt5HZtp18+J1TttOBDeL1vh7TAAGgmgipYN15xN 3xQnvjOr4Kugc7ZIAY3eQpaCTJ0vhk0TacH7tFQ9z4y9nHq5OHwgX6ULqzpqboPhqhEnII1H tifNFL2MiGTkS55JCrThXesMFJZ2el8phgfvU++EVdlIW0D6ERkelZKlWiV52nvcGv5UySc2 /N3vmgm9XuG+7JIikw+/4Rku1ETX/5EPtGVklk0zP8UEhLAw9hwgh6ysAGr7itOp6z7hS8Ge +itIagcjzZ7N2vk3WtzsNo9Boo8kgb6JIu4bF+n57aPMHloHfaVt13IzcbZuSWt124hyNssc J2WVbUfpOZic+O6O8skNEyxO3dkn/nonkECqxWiwdGT8Ph1nFp9lOqbewNsot89bz+ZnpvdP 7XFC5yhQkhN9fWzGLTGYzyN3dni7LauEdNuZF8a0fd2QhhQBjXUCKHePEW/bFHLeIhMP9l5V Q5ZmMe9EWkCetks/Sue32LkBlk643kwngmsSi5o/7z83zRZRobZhK0nUVDlJ1SmUf1w9xAWj hKOnqkSYEPO7iCD5F8WzvXghQ2fAWaUMYMLw1hNl22DNa155o7b4wSLbX2AQBER1ZK5lGoOw sEjjfeqHkRKyvpEY5yk/Lg3bW2YnOLYOGAAmaqX97rQBxJOciHwIyMrifvrrST9JLImhUzZJ PQcc0I5vgDC4gdO2v6lQDhU2ABZExuEvAPq7xflYyiTfmMU+xhRo2AIyPACtvvXdIjJokGQ7 U/41Ovst0PR5Ox5m6N+maePmbiMIS5mpeV2NU6phky65bT6c7b1wEeQvrBxLqFv6lirsTGGL 1jybjYyVahFrdZcauySwC1y3Qeb6o8WhQTQFwFAwcZ8dRyy6sQ6Xprg9v84UK0vIa2wovwpe rMKNAPhDvFQNgjvGvuNoNtS2NCl7+VbSRSipNGaXz+Q+trovFnhTw69Vr1qufz1x8lbkhgLj PZAcRel7HeYNw4NY9oOeJ3vrfE6COmzP6KSHQ7z4sxKpCsaEeD6neJFwisQhNPqqrcSadXCM Ull57Q7biDZVwQTbK8GImZq70Qn67Ipg4j0bbdto+/WsKmAnRPan46VYthwILeWYL7YCF6JL 1dZR37G4jHRzterg95/hGS2R+x+eOmBY/BjTPhMrkgjrl21sLpuR56ZGg2T/ynnc2Yi1rUhA fpNMUzwVnzxk3EUo8a7fxLgMvRIi+HvXgNjooIwWI3tKIb2qrBPv1lR/eGoZa39S604fQubW YsyY45Pr6yMXpwlIl+okwYyDP3GiQlXqbtV02Q/SCZPPRRATlGM/SOpQP41ONfO56PHn/mqc Y9DzbXIdZr3t5rjz7S7SrqtuZm/t5WIwQtcDv+4/ao7nuItrZT2DeQld2rQT0rT0KxzLE8DA VLXGiyPZPmofZXXILp3bBAmq4ASWSM4Mj8UV0XxQOCYtOYmBtADj8ZiLTJ33PPp6TRov0D0C U37QmqowemjG1YVQA1jJKZBD/dU5txSwV1tM3LrM3aO4W0jOkeHeBIkbIxzFfz0lRn7hFu0O eSmECpjEEJ6MKRuyGIQDSH4ZnClnsLJMoGyAhYY0H9LNw7VYWljT4JKCsSUsginHsWkfpNFd LA4e2XJVKCdcIvcV3Zox5yo0mRdKJUL7QHFg3oAShe4czjy5FVTmTs/fUdd42hIDHwj8e74w TQnXTz1yR/vAg1f1RTzJuDvIAjg8mPuvWakIt+UOSyIe9va0NHnzoE78JvDCImuM2vVGSm9x jnARFxmYc0G7z6PcKFDPBkibLoT1UOahcc59Pcc21IUawYrufLG9EeVJ/FaPv79str+qggEr 4PwQK1HzLQAojdxtJmgBHKfZxP4dvJf5ER2UhCiQ0/Rqrl8y/Ny8MycUYsDEMFXcqiuS+7Bx 0Teyb2QkewpSqKqok5mJkMrDM+JjGDJ3UPAVKI9kBc0N9UgFT1lFFvs9enwxUfjbZXEf91wg 8QFzPPLFANtJXgzA45JWRYIMfrS8BHSkQKcz/UdTUY5GG3Z3hcoV9jE8J8EKelGP5R4wWUaL ZZX45+gixs7YbsLVp0+Tbs6CeMAEKMzJn30q1EBqXerUjzttZTn4eaClIvgtegh55gJYzjnn w85oxoAgryb/qO+6k564/yGrPp9ZpcOD9rMS9jt2QqmIB9LXj8NTUJ+T0lhLzIxh3fHj5+3J vRgeC9pnB1Zy12l+K3+vNbh2Xvz8e4R1e+B4bP3yj26rZjEvZv2eSTwhBzwQ90FN0vrE5kXp ZZGRqlOv1fNMvvHU7I1i9AumAPKZT4u0NYT+XFLlADNw6mUhum+kq2EuT+1hRpZYyAQxAvkO fKQgeeX59VA4qCEmjXVbobzQjLpcOsJgqO82Rt5j+W9mvdKUCPzkQOAANbCRFUga9PIgeLjN ZWmKPsqJ8kTyiDIv8mBaF4G/kMqEmLN+fF71aZOwPnX8t0t7AwxZZkXP7bJnRExWP+hQ6zo0 x5hEKii825iFmNECXiiCyOofN+Iweb8oJ2XSk+dsWXT/EZYc+zdH6niBWwLSCfXfrFkBRznA bIE3eRz56Sgx+SzF+uSWLcGiPw86AZjPh+/5akA8jcqxwH9dm8vX4N5bRh966nfKiapc4DwO yOQwyAAlopGYBwyw7EC7WQYhGKHmoD3FbhTOxT60MnXbtoqe7/6WCnxwKQSH1It5bwf4ygY7 dYmN9TwVzg5J3mAa/VCCXXY8Gkdz7m1d+RDNCnT4j6ukkiwC7PkkW8EZPN90p2DK15EOa/Wy Vj+jm+we9kjKI2WsvdFfrQ/fomcghnfz6cXa5AoecP7Uc1HEpghsp3c4vzwRLCyIWZJttQq+ FD1B/T7VBqwhcpFpwNJWC+N0IdmvdsyKk3DToTYOyZJZbZ5GMFyMC+flBC9UdciYULQz8BMQ lDp07gUIbIdkKuQ7qvfFIw1uGJZk7pXnd203ivEe3tJStYtBy74kBRO6GdhA5m/b4Z7eTqdo 6DBJNN+8oR7gFRrvwFR5nDcBVQUViEwazRkmaDkoQ5XaDnMSOcMqmN/KKzC7uV6aMpemqGOs oUBZF0ZwzPjyCqAzoJM1tj7Vue4q/m3B4VLSJx836mHpunVI1GpGWC1Pr9VCMUb5ycPYWVLa 1hgoE5JrMvHsQtIbOCvhcoJrNkpcGCyVpgl9BTICbpxmL9yP9YK2qqY1orPZYbGD18a2VgHD MeGD9+ZUwHAJ0Tp60EwyVaxjP6osAZvjskTQ3q72M5PyDWZucB15s71ByFeUwZTk+3jqftAK JOQF6YFWx35egnzGeRb8qlQxd9LGtIpEi7GhbcaoAd9r9HR/NaEbVnaiVL6b+9dJz6Fwn99A lNY2XZBsjJNjctvqdnOea+/dYndE4TsNuWQykWU/v9/GTONv0mx53E+BfSvyAUEkg2JebDS9 lNA5yYi2xjI9j8yerZaFufiaxs4x8nWJ1a4dH7KtHY8Vpfcs3RnAWdsgMtvcb4vp45UsMc/Q 8/dJD025MhbO+RUufsiBBenM6YBiHj/tN2g7o3ZkQhlffG/I3t9ip0mSlf6ZqRyYcaOOCZGB yUazQNLIEb36VU4Kc3IIEXZD3EAxilvbRa4S8kh1GqryqnUc9KJvooctXIEa67XBliJFl2U8 yEvnMX0SGS6TbN4nFbWDCIoS6L/i/6taxTr9vO600vs2F+gpen+IZxaZQfoIO27yHGBr+OIA 2tgqPqz4IGVbjCG9KhFplQURLGm5I0xhfsC4etX+f2BJsbaVz4lPSnd7WZkBcEC2o0ZgKyHG D/8K3oapFcuVrGcIcNRqXVM4f5TfjTbrNhLVkF7AmAm5Ys0cUMxQ947LF/5Wd6xZzb3e5xOQ CZlUtGXHfZNv9JvcylGx1Qslrbp9tEi2K6PE7DjHTpnwDvAiITOo4uu7njSoywzupRlRU2bW BGG/ltkTqpAQ/Lv2FKRr638vs7V3pbcNTHNQF7fV1dQ/M7KLjMDXZ5asHwwetB6bi7r99U3r Iu7QlhpnpAxch+hV5+ykFX+fJsp21RmUh6Fo5yPZ8dKDjByXY2i/bzVeVtzcPDqp0hvEMwTs FFJ7pooa9/QKkhtG0FsZWvPS1BU30xT/26Uh0oUTq0eVXtoKLGw1EG4Hotf2iAwgtLtmZgQY H6OcheN5gEE5UvDy2z7H7w7o+lIRbhWhof42Qmed7vSp0MTiy0P7Y9kQRJVao1Z0f/e/YihK VTQKlA+WrE8PpAU+uNNxrk8KWx94T+ygAKTFytf1jd9+8hqJ3PDYmGlg9ZQX1BDXm/y266JO 1s6xc8iRukxC6zrSjtXnixm+9HzNh83W6AdxzZW6emHYR5YObZFFaC+AkCtP/I238Ql3eZc8 ZoBhyEXEhVhzvaP0SJnBtu1HElULxLVaXttWUTUwzoz6aYlPd7cr3kPf/zSkAx9shySYXYWQ 66OKD8FzwYVzDXMM9dIMP8pNq7/9uh8mrwNoFXeM/6qNIRAV8BH4ocaU0sn/Qw0HaH9lSj1/ mQAkOQb5ikUMDdok3z59t2/qlRV3uTQdlzNsoTMZNNbP3hSd+hHgKFB2rSFpvwYaF+etxSt6 gn9jLu8LWeOENA5q4TtZaJuqF+KoZFLVetW8s9iAtZf65+MMSuxcTDg7vtxRktRfs7BtsM8n pnW457MvIjUhto0ATKg7TO0iS8ljMnfjYwsm+7Hl4spceQrSOPgg3cL3ag1Qy3XyhnE8DdHj 9AIIEyG+AFblyK/UPQJBgiEkI4L/nSOJ7JvDb7sVYJ4ttcFi4u0ASlCh4AWc87sJmIihlqRg FXR5WJYTgQZQk8GF4Bo77oySikAYhHcJTOzZcjeaUAI/MHD5wFqntdBk1DC0FjDCos50/6JO Ikd+3xA5VPNmEwPQ4t6u3Rjam7wYRvH3NN16/IIr8nqOmpEfW4m9ej1oIuNb6Hd6SA8jFAy4 tk5W95aYg1QleLPtmerZoEvf4dvQpSjsngFiUfH8I1eeZtY1LvtKPhhGuMw2hL04VM2L+yGf qnwo7GHOUGUz8M+iUavK9mYFgHPepcAW8d0gXraC95PtJG/MxA3SDS/aI0qtLkNYke0CCwSc MrZ1IIyUZTCODk+aEze2K/43j5+4eNZK1iYbq72RzpEbLP4xUhO/e+Bk5gHbEbyk2BO6NJFE LidjSKzj8XjMUmwiKcOjPQ9W7aXGLd004r+HTaUprhT1rZvBtQytU3ONaJaZ4OvMEam284nb 4mLZYTF3qtK5s88/Cv3yI8nN3tEd8uuAKvSWYTcWRJceEbElCJ2N1e9FZHrSwjj09cXgJ9AT EV/YFDj3X0saXZgjEzy9BP0DITJJa82nZq4hGwmBV/AFTrMn6jLUtFi4GrbFgfJ4KWTf/70P RXlQlB4eIN+DCcJMhNMMfVSBJdeJpILzUi+iIWLOmZRRHTlfiG74JZfvUwrHX/fmvgKj1Vg/ shk3wiqq4OeBLz26tPAW3Er9Ra7uUG5NB6nqdxoAmYi+jJFtGNvz9YJyMSiXEW3nVL7d0W3D EPhMnQziXaiEAgO8oqvXXgjl4ULU5qXm4Mq0rhrILSgTEl5ra1GMUmg8DYDTrhPETlTfh5i6 SEPm/o1bnobLzy3l9LoduilFkZL/ahn14oA2nx0OVAGcIXMut6nboQrBePZ0IM90JBOmQb3w oovVhPd3tsO3fURg5m5bcfukPfPtHxjAWrOBOCkWL6vXU1KUrwyPQKUKU8Bihei3VLhjUKNE FJOy3jhzzbntlGbyLHbd68DuGQDDbK2kOUcrNGRc02hkh8PRjAjWZ/XbOt4rLnlTTqA2jArO aPavxxQrX9YJDqghd+24xSNYV4a+iHG2mzSZE0KB8bH8f2WXcNNSnkDzzOSNG2ld48XHRcLn DEpm9IQwOxxh85P80WR44TsGkK372nAH512fXASYP1WSUrsFAjWhStf3KfSrgU4ImEdcb4iU DYpIGWN8gau4FeSBmyV5yjzP/+YZNgDFe6/0C3RF7p9207xaONOJ86fV4IGnA7NhX5teCRoF Fs24Df8jWZXWmDCyaFMP1cNbeh0DWpL/hhk3FkNwWQrpfA+8r6WtKKQww5hT9caK2hJaqtv2 xpBiRaWeWrp4tMcCdOAQGRjjPwsOBLwGTkvpxHyPuG9hhe8r/007y4HwQKeXVUUM1ZO7RBjU XhqnXXh4WPwAEOj0RyuaOeLCI/PzrbovRL8uu2qjp2mDpe8zk/5h4mWyF1mIaeAHQM8Y+5kQ N5eja2pGFSkr6NAt4BEESwuX70bK/bWWkEm6Cn1jnAA60NhwJw2eOgAB8NcDn8O1BAAAANnE R40UFzswAwAAAAAEWVo= --ySC0KhfPSntW7mR+-- --bc8cpYMQSq8NcNIO Content-Type: application/pgp-signature; name="signature.asc" -----BEGIN PGP SIGNATURE----- iQIzBAABCAAdFiEEuQK1JxMl+JKsJRrUQWM7n+g39YEFAmHiEigACgkQQWM7n+g3 9YGYYhAAj7fKFREM5sPn1yGHw26MKv4V3spGIFl1vdHsEfGF7yAVpJkRmzmlLopU KbyZYPmRcbFAjc3AQnA4OWQTaHzOS29i5YFDs2asrJwIHnE4ADTjF6H05h1FtFjW mI3Nph9Kub7J0DyX98Wx/LiTkHgv3vxaE0YzgCkvmY4pjgtgLGsAo+REWNO6lOTA GSgfcsFVaCwa5tuO1lwXRjQnciKaX5z+yR2QhCsIR+DzBTtqCcEJWOvdoV5/zZnw Sgct7jICgUczsP/Jv2uSrZPOVOh4d3FPvWU5hUpvAxIL5iaPXpoYaLq0lqyxn91f DqCy6jjQJrVYMLOEk2cGSAZ/f9f7OHaNNntzDOBrt6OYz1cPQUgs0vlqtsNghrMn sbu7vIRU9chVrInyBEcwTp0SjkB/3nVEuBFdDLW58uosjFGywjcrVHVY57D1v5s0 1uUqj4sKiZyf9kn4DdTcVyaKM/P3yU/G9aaNPzoCiKj75Uk2eGFEZ05HaSLxLNjf 4Ag1YoyMEChygAKGnqtfCaY/XAfkL+yKQGvy13QotNI4fKNbxhLgxF2UdMRc1ow9 +8sMr8dkzsSomwtCd9oteyKHtPRzjkW5Bgv3GCxXuplm7EdFc9d5xZZEQGaEa1jx 5vWb6AS6Yig5sJZ8uVTjLoD6ExMwQTjqjwJL04Y8KEI8tTzS5w4= =AZJD -----END PGP SIGNATURE----- --bc8cpYMQSq8NcNIO--