From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-ed1-x530.google.com (mail-ed1-x530.google.com [IPv6:2a00:1450:4864:20::530]) by sourceware.org (Postfix) with ESMTPS id 036C33858426 for ; Thu, 3 Nov 2022 08:55:42 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 036C33858426 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=gmail.com Received: by mail-ed1-x530.google.com with SMTP id x2so1979466edd.2 for ; Thu, 03 Nov 2022 01:55:41 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:from:to:cc:subject:date:message-id:reply-to; bh=FFCl9fFvLSK14PhvRCefnTXz7dffqYKzvYH9D4Ecssk=; b=Si47s9LoTaJKdJ+Ls5qdtjtU/yhq1MpV7ZxWv+7CghHYpJRUN3mEfmTVYXifDOcsCF QgBlIi4VrUlBeZWwT2WjzJfmJmRC3uTBVZCLHML7P0GBsxERWhaMpQJ2CyQp7Qc1xmFS gz6h6ZEwewglDOHyP0FFLWwkBjqJLAsaO/LraEu9eXgan85Q5lUBjg/jixGgCkrMr/3s SwRGVbnWm1Oq2vSNVL+P90TwoWqxRw7PpVHKo6Rl9zAgbmdKR978VrSX00zvOMX8EY9o 5FxuoVyM0bFzMt161dE41GjJUqr9OuZwe0BUr8euvxhsXxTtpNViZOS/JVML8OAHbDnS NmxQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=cc:to:subject:message-id:date:from:in-reply-to:references :mime-version:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to; bh=FFCl9fFvLSK14PhvRCefnTXz7dffqYKzvYH9D4Ecssk=; b=jMeJ+/iB586FR2/wjLrM23kiJ/3+uJcLlFIfD2Yvqoh3JsUjRMBBMyVe5H0O9u2vJW TZ0ZEjd/t7mnsP9qoH02Lce2zxyosNC6sba4ZHKoVBIsT7XgelMyP3EWgH1dEry6z2ZL OhnPAFtfyF/qsDomoeebJfme7oGJkRG1SFmh5WNBxqUpVq7bIj5fYP3KNgc0EVTq0pty /NrjJ0BzcbUitK7qdCP5eC1BJQD9VrKiUhw1vseNdco+AZcBrvg4ADcZhL69fn4Jgw/F ZuDnLvP+FHLXI/W6Qa5tBVX92/57ENF9BZ2rfysQQTTm4l8mK4teSbR/oKVTSmmDQBAI 3ZfQ== X-Gm-Message-State: ACrzQf2VjMi8b2pieSXPmuUcnTCGWrNlxHFIBVtAHO0Ps3SB5XDr1krc nFe12jsyPBysVZ9hykoqjKE3EWr2oKQg1z40gv7Abkz0rQU= X-Google-Smtp-Source: AMsMyM7FVEeHTh7GsPC3zHXZWnlb1OUKw7XqUz7Cs8PzChhZWhTjgk18612agNRDQthsHaNO0SIfwTxQfi6Y2O56qkM= X-Received: by 2002:a05:6402:c07:b0:461:87ab:78aa with SMTP id co7-20020a0564020c0700b0046187ab78aamr29235713edb.258.1667465738066; Thu, 03 Nov 2022 01:55:38 -0700 (PDT) MIME-Version: 1.0 References: <20221103085314.1069528-1-goldstein.w.n@gmail.com> <20221103085314.1069528-2-goldstein.w.n@gmail.com> In-Reply-To: <20221103085314.1069528-2-goldstein.w.n@gmail.com> From: Noah Goldstein Date: Thu, 3 Nov 2022 01:55:23 -0700 Message-ID: Subject: Re: [PATCH v1 2/4] x86: Optimize and shrink st{r|p}{n}{cat|cpy}-evex functions To: libc-alpha@sourceware.org Cc: hjl.tools@gmail.com, carlos@systemhalted.org Content-Type: multipart/mixed; boundary="000000000000fe52e705ec8d1e3a" X-Spam-Status: No, score=-9.4 required=5.0 tests=BAYES_00,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,FREEMAIL_FROM,GIT_PATCH_0,KAM_SHORT,RCVD_IN_DNSWL_NONE,SPF_HELO_NONE,SPF_PASS,TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: --000000000000fe52e705ec8d1e3a Content-Type: text/plain; charset="UTF-8" On Thu, Nov 3, 2022 at 1:53 AM Noah Goldstein wrote: > > Optimizations are: > 1. Use more overlapping stores to avoid branches. > 2. Reduce how unrolled the aligning copies are (this is more of a > code-size save, its a negative for some sizes in terms of > perf). > 3. Improve the loop a bit (similiar to what we do in strlen with > 2x vpminu + kortest instead of 3x vpminu + kmov + test). > 4. For st{r|p}n{cat|cpy} re-order the branches to minimize the > number that are taken. > > Performance Changes: > > Times are from N = 10 runs of the benchmark suite and are > reported as geometric mean of all ratios of > New Implementation / Old Implementation. > > stpcpy-evex -> 0.922 > strcat-evex -> 0.985 > strcpy-evex -> 0.880 > > strncpy-evex -> 0.831 > stpncpy-evex -> 0.780 > > strncat-evex -> 0.978 > > Code Size Changes: > function -> Bytes New / Bytes Old -> Ratio > > strcat-evex -> 819 / 1874 -> 0.437 > strcpy-evex -> 700 / 1074 -> 0.652 > stpcpy-evex -> 735 / 1094 -> 0.672 > > strncpy-evex -> 1397 / 2611 -> 0.535 > stpncpy-evex -> 1489 / 2691 -> 0.553 > > strncat-evex -> 1166 / 2832 -> 0.412 > > Notes: > Because of the significant difference between the > implementations they are split into three files. > > strcpy-evex.S -> strcpy, stpcpy, strcat > strncpy-evex.S -> strncpy > strncat-evex.S > strncat > > I couldn't find a way to merge them without making the ifdefs > incredibly difficult to follow. > > All implementations can be made evex512 by including > "x86-evex512-vecs.h" at the top. > > Full check passes on x86-64 and build succeeds for all ISA levels w/ > and w/o multiarch. > --- > > Results attached. > sysdeps/x86_64/multiarch/stpncpy-evex.S | 5 +- > sysdeps/x86_64/multiarch/strcat-evex.S | 291 +--- > sysdeps/x86_64/multiarch/strcat-strlen-evex.S | 88 ++ > sysdeps/x86_64/multiarch/strcpy-evex.S | 1282 ++++++----------- > sysdeps/x86_64/multiarch/strncat-evex.S | 517 ++++++- > sysdeps/x86_64/multiarch/strncpy-evex.S | 995 ++++++++++++- > .../multiarch/strncpy-or-cat-overflow-def.h | 65 + > 7 files changed, 2070 insertions(+), 1173 deletions(-) > create mode 100644 sysdeps/x86_64/multiarch/strcat-strlen-evex.S > create mode 100644 sysdeps/x86_64/multiarch/strncpy-or-cat-overflow-def.h > > diff --git a/sysdeps/x86_64/multiarch/stpncpy-evex.S b/sysdeps/x86_64/multiarch/stpncpy-evex.S > index 99ea76a372..3693491baa 100644 > --- a/sysdeps/x86_64/multiarch/stpncpy-evex.S > +++ b/sysdeps/x86_64/multiarch/stpncpy-evex.S > @@ -3,6 +3,5 @@ > #endif > > #define USE_AS_STPCPY > -#define USE_AS_STRNCPY > -#define STRCPY STPNCPY > -#include "strcpy-evex.S" > +#define STRNCPY STPNCPY > +#include "strncpy-evex.S" > diff --git a/sysdeps/x86_64/multiarch/strcat-evex.S b/sysdeps/x86_64/multiarch/strcat-evex.S > index 0e2df947e9..b4207b7889 100644 > --- a/sysdeps/x86_64/multiarch/strcat-evex.S > +++ b/sysdeps/x86_64/multiarch/strcat-evex.S > @@ -1,286 +1,7 @@ > -/* strcat with 256-bit EVEX instructions. > - Copyright (C) 2021-2022 Free Software Foundation, Inc. > - This file is part of the GNU C Library. > - > - The GNU C Library is free software; you can redistribute it and/or > - modify it under the terms of the GNU Lesser General Public > - License as published by the Free Software Foundation; either > - version 2.1 of the License, or (at your option) any later version. > - > - The GNU C Library is distributed in the hope that it will be useful, > - but WITHOUT ANY WARRANTY; without even the implied warranty of > - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > - Lesser General Public License for more details. > - > - You should have received a copy of the GNU Lesser General Public > - License along with the GNU C Library; if not, see > - . */ > - > -#include > - > -#if ISA_SHOULD_BUILD (4) > - > - > -# include > - > -# ifndef STRCAT > -# define STRCAT __strcat_evex > -# endif > - > -# define VMOVU vmovdqu64 > -# define VMOVA vmovdqa64 > - > -/* zero register */ > -# define XMMZERO xmm16 > -# define YMMZERO ymm16 > -# define YMM0 ymm17 > -# define YMM1 ymm18 > - > -# define USE_AS_STRCAT > - > -/* Number of bytes in a vector register */ > -# define VEC_SIZE 32 > - > - .section .text.evex,"ax",@progbits > -ENTRY (STRCAT) > - mov %rdi, %r9 > -# ifdef USE_AS_STRNCAT > - mov %rdx, %r8 > -# endif > - > - xor %eax, %eax > - mov %edi, %ecx > - and $((VEC_SIZE * 4) - 1), %ecx > - vpxorq %XMMZERO, %XMMZERO, %XMMZERO > - cmp $(VEC_SIZE * 3), %ecx > - ja L(fourth_vector_boundary) > - vpcmpb $0, (%rdi), %YMMZERO, %k0 > - kmovd %k0, %edx > - test %edx, %edx > - jnz L(exit_null_on_first_vector) > - mov %rdi, %rax > - and $-VEC_SIZE, %rax > - jmp L(align_vec_size_start) > -L(fourth_vector_boundary): > - mov %rdi, %rax > - and $-VEC_SIZE, %rax > - vpcmpb $0, (%rax), %YMMZERO, %k0 > - mov $-1, %r10d > - sub %rax, %rcx > - shl %cl, %r10d > - kmovd %k0, %edx > - and %r10d, %edx > - jnz L(exit) > - > -L(align_vec_size_start): > - vpcmpb $0, VEC_SIZE(%rax), %YMMZERO, %k0 > - kmovd %k0, %edx > - test %edx, %edx > - jnz L(exit_null_on_second_vector) > - > - vpcmpb $0, (VEC_SIZE * 2)(%rax), %YMMZERO, %k1 > - kmovd %k1, %edx > - test %edx, %edx > - jnz L(exit_null_on_third_vector) > - > - vpcmpb $0, (VEC_SIZE * 3)(%rax), %YMMZERO, %k2 > - kmovd %k2, %edx > - test %edx, %edx > - jnz L(exit_null_on_fourth_vector) > - > - vpcmpb $0, (VEC_SIZE * 4)(%rax), %YMMZERO, %k3 > - kmovd %k3, %edx > - test %edx, %edx > - jnz L(exit_null_on_fifth_vector) > - > - vpcmpb $0, (VEC_SIZE * 5)(%rax), %YMMZERO, %k4 > - add $(VEC_SIZE * 4), %rax > - kmovd %k4, %edx > - test %edx, %edx > - jnz L(exit_null_on_second_vector) > - > - vpcmpb $0, (VEC_SIZE * 2)(%rax), %YMMZERO, %k1 > - kmovd %k1, %edx > - test %edx, %edx > - jnz L(exit_null_on_third_vector) > - > - vpcmpb $0, (VEC_SIZE * 3)(%rax), %YMMZERO, %k2 > - kmovd %k2, %edx > - test %edx, %edx > - jnz L(exit_null_on_fourth_vector) > - > - vpcmpb $0, (VEC_SIZE * 4)(%rax), %YMMZERO, %k3 > - kmovd %k3, %edx > - test %edx, %edx > - jnz L(exit_null_on_fifth_vector) > - > - vpcmpb $0, (VEC_SIZE * 5)(%rax), %YMMZERO, %k4 > - kmovd %k4, %edx > - add $(VEC_SIZE * 4), %rax > - test %edx, %edx > - jnz L(exit_null_on_second_vector) > - > - vpcmpb $0, (VEC_SIZE * 2)(%rax), %YMMZERO, %k1 > - kmovd %k1, %edx > - test %edx, %edx > - jnz L(exit_null_on_third_vector) > - > - vpcmpb $0, (VEC_SIZE * 3)(%rax), %YMMZERO, %k2 > - kmovd %k2, %edx > - test %edx, %edx > - jnz L(exit_null_on_fourth_vector) > - > - vpcmpb $0, (VEC_SIZE * 4)(%rax), %YMMZERO, %k3 > - kmovd %k3, %edx > - test %edx, %edx > - jnz L(exit_null_on_fifth_vector) > - > - vpcmpb $0, (VEC_SIZE * 5)(%rax), %YMMZERO, %k4 > - add $(VEC_SIZE * 4), %rax > - kmovd %k4, %edx > - test %edx, %edx > - jnz L(exit_null_on_second_vector) > - > - vpcmpb $0, (VEC_SIZE * 2)(%rax), %YMMZERO, %k1 > - kmovd %k1, %edx > - test %edx, %edx > - jnz L(exit_null_on_third_vector) > - > - vpcmpb $0, (VEC_SIZE * 3)(%rax), %YMMZERO, %k2 > - kmovd %k2, %edx > - test %edx, %edx > - jnz L(exit_null_on_fourth_vector) > - > - vpcmpb $0, (VEC_SIZE * 4)(%rax), %YMMZERO, %k3 > - kmovd %k3, %edx > - test %edx, %edx > - jnz L(exit_null_on_fifth_vector) > - > - test $((VEC_SIZE * 4) - 1), %rax > - jz L(align_four_vec_loop) > - > - vpcmpb $0, (VEC_SIZE * 5)(%rax), %YMMZERO, %k4 > - add $(VEC_SIZE * 5), %rax > - kmovd %k4, %edx > - test %edx, %edx > - jnz L(exit) > - > - test $((VEC_SIZE * 4) - 1), %rax > - jz L(align_four_vec_loop) > - > - vpcmpb $0, VEC_SIZE(%rax), %YMMZERO, %k0 > - add $VEC_SIZE, %rax > - kmovd %k0, %edx > - test %edx, %edx > - jnz L(exit) > - > - test $((VEC_SIZE * 4) - 1), %rax > - jz L(align_four_vec_loop) > - > - vpcmpb $0, VEC_SIZE(%rax), %YMMZERO, %k0 > - add $VEC_SIZE, %rax > - kmovd %k0, %edx > - test %edx, %edx > - jnz L(exit) > - > - test $((VEC_SIZE * 4) - 1), %rax > - jz L(align_four_vec_loop) > - > - vpcmpb $0, VEC_SIZE(%rax), %YMMZERO, %k1 > - add $VEC_SIZE, %rax > - kmovd %k1, %edx > - test %edx, %edx > - jnz L(exit) > - > - add $VEC_SIZE, %rax > - > - .p2align 4 > -L(align_four_vec_loop): > - VMOVA (%rax), %YMM0 > - VMOVA (VEC_SIZE * 2)(%rax), %YMM1 > - vpminub VEC_SIZE(%rax), %YMM0, %YMM0 > - vpminub (VEC_SIZE * 3)(%rax), %YMM1, %YMM1 > - vpminub %YMM0, %YMM1, %YMM0 > - /* If K0 != 0, there is a null byte. */ > - vpcmpb $0, %YMM0, %YMMZERO, %k0 > - add $(VEC_SIZE * 4), %rax > - ktestd %k0, %k0 > - jz L(align_four_vec_loop) > - > - vpcmpb $0, -(VEC_SIZE * 4)(%rax), %YMMZERO, %k0 > - sub $(VEC_SIZE * 5), %rax > - kmovd %k0, %edx > - test %edx, %edx > - jnz L(exit_null_on_second_vector) > - > - vpcmpb $0, (VEC_SIZE * 2)(%rax), %YMMZERO, %k1 > - kmovd %k1, %edx > - test %edx, %edx > - jnz L(exit_null_on_third_vector) > - > - vpcmpb $0, (VEC_SIZE * 3)(%rax), %YMMZERO, %k2 > - kmovd %k2, %edx > - test %edx, %edx > - jnz L(exit_null_on_fourth_vector) > - > - vpcmpb $0, (VEC_SIZE * 4)(%rax), %YMMZERO, %k3 > - kmovd %k3, %edx > - sub %rdi, %rax > - bsf %rdx, %rdx > - add %rdx, %rax > - add $(VEC_SIZE * 4), %rax > - jmp L(StartStrcpyPart) > - > - .p2align 4 > -L(exit): > - sub %rdi, %rax > -L(exit_null_on_first_vector): > - bsf %rdx, %rdx > - add %rdx, %rax > - jmp L(StartStrcpyPart) > - > - .p2align 4 > -L(exit_null_on_second_vector): > - sub %rdi, %rax > - bsf %rdx, %rdx > - add %rdx, %rax > - add $VEC_SIZE, %rax > - jmp L(StartStrcpyPart) > - > - .p2align 4 > -L(exit_null_on_third_vector): > - sub %rdi, %rax > - bsf %rdx, %rdx > - add %rdx, %rax > - add $(VEC_SIZE * 2), %rax > - jmp L(StartStrcpyPart) > - > - .p2align 4 > -L(exit_null_on_fourth_vector): > - sub %rdi, %rax > - bsf %rdx, %rdx > - add %rdx, %rax > - add $(VEC_SIZE * 3), %rax > - jmp L(StartStrcpyPart) > - > - .p2align 4 > -L(exit_null_on_fifth_vector): > - sub %rdi, %rax > - bsf %rdx, %rdx > - add %rdx, %rax > - add $(VEC_SIZE * 4), %rax > - > - .p2align 4 > -L(StartStrcpyPart): > - lea (%r9, %rax), %rdi > - mov %rsi, %rcx > - mov %r9, %rax /* save result */ > - > -# ifdef USE_AS_STRNCAT > - test %r8, %r8 > - jz L(ExitZero) > -# define USE_AS_STRNCPY > -# endif > - > -# include "strcpy-evex.S" > +#ifndef STRCAT > +# define STRCAT __strcat_evex > #endif > + > +#define USE_AS_STRCAT > +#define STRCPY STRCAT > +#include "strcpy-evex.S" > diff --git a/sysdeps/x86_64/multiarch/strcat-strlen-evex.S b/sysdeps/x86_64/multiarch/strcat-strlen-evex.S > new file mode 100644 > index 0000000000..9813d38613 > --- /dev/null > +++ b/sysdeps/x86_64/multiarch/strcat-strlen-evex.S > @@ -0,0 +1,88 @@ > + /* Simple strlen implementation that ends at L(strcat_strlen_done). */ > + vpxorq %VZERO_128, %VZERO_128, %VZERO_128 > + /* Paired down strlen implementation. We never commit to 4x > + loop as we are expecting a relatively short string and want > + to minimize code size. */ > + movq %rdi, %r8 > + andq $(VEC_SIZE * -1), %r8 > + VPCMPEQ (%r8), %VZERO, %k0 > + KMOV %k0, %VRCX > +#ifdef USE_AS_WCSCPY > + subl %r8d, %edi > + shrl $2, %edi > +#endif > + shrx %VRDI, %VRCX, %VRCX > +#ifdef USE_AS_WCSCPY > + movq %rax, %rdi > +#endif > + test %VRCX, %VRCX > + jnz L(bsf_and_done_v0) > + > + > + VPCMPEQ VEC_SIZE(%r8), %VZERO, %k0 > + KMOV %k0, %VRCX > + leaq (VEC_SIZE)(%r8), %rdi > + test %VRCX, %VRCX > + jnz L(bsf_and_done_v0) > + > + VPCMPEQ (VEC_SIZE * 2)(%r8), %VZERO, %k0 > + KMOV %k0, %VRCX > + test %VRCX, %VRCX > + jnz L(bsf_and_done_v1) > + > + VPCMPEQ (VEC_SIZE * 3)(%r8), %VZERO, %k0 > + KMOV %k0, %VRCX > + test %VRCX, %VRCX > + jnz L(bsf_and_done_v2) > + > + VPCMPEQ (VEC_SIZE * 4)(%r8), %VZERO, %k0 > + KMOV %k0, %VRCX > + test %VRCX, %VRCX > + jnz L(bsf_and_done_v3) > + > + andq $-(VEC_SIZE * 4), %rdi > + .p2align 4,, 8 > +L(strlen_loop_4x_vec): > + VMOVA (VEC_SIZE * 4)(%rdi), %VMM(0) > + VPMIN (VEC_SIZE * 5)(%rdi), %VMM(0), %VMM(1) > + VMOVA (VEC_SIZE * 6)(%rdi), %VMM(2) > + VPMIN (VEC_SIZE * 7)(%rdi), %VMM(2), %VMM(3) > + VPTESTN %VMM(1), %VMM(1), %k1 > + VPTESTN %VMM(3), %VMM(3), %k3 > + subq $(VEC_SIZE * -4), %rdi > + KORTEST %k1, %k3 > + jz L(strlen_loop_4x_vec) > + > + VPTESTN %VMM(0), %VMM(0), %k0 > + KMOV %k0, %VRCX > + test %VRCX, %VRCX > + jnz L(bsf_and_done_v0) > + > + KMOV %k1, %VRCX > + test %VRCX, %VRCX > + jnz L(bsf_and_done_v1) > + > + VPTESTN %VMM(2), %VMM(2), %k0 > + KMOV %k0, %VRCX > + test %VRCX, %VRCX > + jnz L(bsf_and_done_v2) > + > + KMOV %k3, %VRCX > +L(bsf_and_done_v3): > + addq $VEC_SIZE, %rdi > +L(bsf_and_done_v2): > + bsf %VRCX, %VRCX > + leaq (VEC_SIZE * 2)(%rdi, %rcx, CHAR_SIZE), %rdi > + jmp L(strcat_strlen_done) > + > + .p2align 4,, 4 > +L(bsf_and_done_v1): > + addq $VEC_SIZE, %rdi > +L(bsf_and_done_v0): > + bsf %VRCX, %VRCX > +#ifdef USE_AS_WCSCPY > + leaq (%rdi, %rcx, CHAR_SIZE), %rdi > +#else > + addq %rcx, %rdi > +#endif > +L(strcat_strlen_done): > diff --git a/sysdeps/x86_64/multiarch/strcpy-evex.S b/sysdeps/x86_64/multiarch/strcpy-evex.S > index 82e45ac675..1ba0195ed2 100644 > --- a/sysdeps/x86_64/multiarch/strcpy-evex.S > +++ b/sysdeps/x86_64/multiarch/strcpy-evex.S > @@ -1,4 +1,4 @@ > -/* strcpy with 256-bit EVEX instructions. > +/* {wcs|wcp|str|stp}cpy with 256/512-bit EVEX instructions. > Copyright (C) 2021-2022 Free Software Foundation, Inc. > This file is part of the GNU C Library. > > @@ -17,990 +17,526 @@ > . */ > > #include > - > #if ISA_SHOULD_BUILD (4) > > > -# ifndef USE_AS_STRCAT > -# include > + /* Use evex-masked stores for small sizes. Turned off at the > + moment. */ > +# define USE_EVEX_MASKED_STORE 0 > + /* Use movsb in page cross case to save code size. */ > +# define USE_MOVSB_IN_PAGE_CROSS 1 > > -# ifndef STRCPY > -# define STRCPY __strcpy_evex > -# endif > +# include > > +# ifndef VEC_SIZE > +# include "x86-evex256-vecs.h" > # endif > > -# define VMOVU vmovdqu64 > -# define VMOVA vmovdqa64 > - > -/* Number of bytes in a vector register */ > -# ifndef VEC_SIZE > -# define VEC_SIZE 32 > +# ifndef STRCPY > +# define STRCPY __strcpy_evex > # endif > > -# define XMM2 xmm18 > -# define XMM3 xmm19 > > -# define YMM2 ymm18 > -# define YMM3 ymm19 > -# define YMM4 ymm20 > -# define YMM5 ymm21 > -# define YMM6 ymm22 > -# define YMM7 ymm23 > +# ifdef USE_AS_WCSCPY > +# define VMOVU_MASK vmovdqu32 > +# define VPMIN vpminud > +# define VPTESTN vptestnmd > +# define VPTEST vptestmd > +# define VPCMPEQ vpcmpeqd > +# define CHAR_SIZE 4 > > -# ifndef USE_AS_STRCAT > +# define REP_MOVS rep movsd > > -/* zero register */ > -# define XMMZERO xmm16 > -# define YMMZERO ymm16 > -# define YMM1 ymm17 > - > - .section .text.evex,"ax",@progbits > -ENTRY (STRCPY) > -# ifdef USE_AS_STRNCPY > - mov %RDX_LP, %R8_LP > - test %R8_LP, %R8_LP > - jz L(ExitZero) > -# endif > - mov %rsi, %rcx > -# ifndef USE_AS_STPCPY > - mov %rdi, %rax /* save result */ > -# endif > +# define USE_WIDE_CHAR > +# else > +# define VMOVU_MASK vmovdqu8 > +# define VPMIN vpminub > +# define VPTESTN vptestnmb > +# define VPTEST vptestmb > +# define VPCMPEQ vpcmpeqb > +# define CHAR_SIZE 1 > > - vpxorq %XMMZERO, %XMMZERO, %XMMZERO > +# define REP_MOVS rep movsb > # endif > > - and $((VEC_SIZE * 4) - 1), %ecx > - cmp $(VEC_SIZE * 2), %ecx > - jbe L(SourceStringAlignmentLessTwoVecSize) > - > - and $-VEC_SIZE, %rsi > - and $(VEC_SIZE - 1), %ecx > - > - vpcmpb $0, (%rsi), %YMMZERO, %k0 > - kmovd %k0, %edx > - shr %cl, %rdx > +# include "reg-macros.h" > > -# ifdef USE_AS_STRNCPY > -# if defined USE_AS_STPCPY || defined USE_AS_STRCAT > - mov $VEC_SIZE, %r10 > - sub %rcx, %r10 > - cmp %r10, %r8 > -# else > - mov $(VEC_SIZE + 1), %r10 > - sub %rcx, %r10 > - cmp %r10, %r8 > -# endif > - jbe L(CopyVecSizeTailCase2OrCase3) > -# endif > - test %edx, %edx > - jnz L(CopyVecSizeTail) > - > - vpcmpb $0, VEC_SIZE(%rsi), %YMMZERO, %k1 > - kmovd %k1, %edx > > -# ifdef USE_AS_STRNCPY > - add $VEC_SIZE, %r10 > - cmp %r10, %r8 > - jbe L(CopyTwoVecSizeCase2OrCase3) > -# endif > - test %edx, %edx > - jnz L(CopyTwoVecSize) > - > - VMOVU (%rsi, %rcx), %YMM2 /* copy VEC_SIZE bytes */ > - VMOVU %YMM2, (%rdi) > - > -/* If source address alignment != destination address alignment */ > - .p2align 4 > -L(UnalignVecSizeBoth): > - sub %rcx, %rdi > -# ifdef USE_AS_STRNCPY > - add %rcx, %r8 > - sbb %rcx, %rcx > - or %rcx, %r8 > -# endif > - mov $VEC_SIZE, %rcx > - VMOVA (%rsi, %rcx), %YMM2 > - VMOVU %YMM2, (%rdi, %rcx) > - VMOVA VEC_SIZE(%rsi, %rcx), %YMM2 > - vpcmpb $0, %YMM2, %YMMZERO, %k0 > - kmovd %k0, %edx > - add $VEC_SIZE, %rcx > -# ifdef USE_AS_STRNCPY > - sub $(VEC_SIZE * 3), %r8 > - jbe L(CopyVecSizeCase2OrCase3) > -# endif > - test %edx, %edx > -# if defined USE_AS_STRNCPY && !defined USE_AS_STRCAT > - jnz L(CopyVecSizeUnalignedVec2) > +# ifdef USE_AS_STPCPY > +# define END_REG rax > # else > - jnz L(CopyVecSize) > +# define END_REG rdi, %rdx, CHAR_SIZE > # endif > > - VMOVU %YMM2, (%rdi, %rcx) > - VMOVA VEC_SIZE(%rsi, %rcx), %YMM3 > - vpcmpb $0, %YMM3, %YMMZERO, %k0 > - kmovd %k0, %edx > - add $VEC_SIZE, %rcx > -# ifdef USE_AS_STRNCPY > - sub $VEC_SIZE, %r8 > - jbe L(CopyVecSizeCase2OrCase3) > -# endif > - test %edx, %edx > -# if defined USE_AS_STRNCPY && !defined USE_AS_STRCAT > - jnz L(CopyVecSizeUnalignedVec3) > +# ifdef USE_AS_STRCAT > +# define PAGE_ALIGN_REG edx > +# define PAGE_ALIGN_REG_64 rdx > # else > - jnz L(CopyVecSize) > +# define PAGE_ALIGN_REG eax > +# define PAGE_ALIGN_REG_64 rax > # endif > > - VMOVU %YMM3, (%rdi, %rcx) > - VMOVA VEC_SIZE(%rsi, %rcx), %YMM4 > - vpcmpb $0, %YMM4, %YMMZERO, %k0 > - kmovd %k0, %edx > - add $VEC_SIZE, %rcx > -# ifdef USE_AS_STRNCPY > - sub $VEC_SIZE, %r8 > - jbe L(CopyVecSizeCase2OrCase3) > -# endif > - test %edx, %edx > -# if defined USE_AS_STRNCPY && !defined USE_AS_STRCAT > - jnz L(CopyVecSizeUnalignedVec4) > -# else > - jnz L(CopyVecSize) > -# endif > +# define VZERO VMM(7) > +# define VZERO_128 VMM_128(7) > > - VMOVU %YMM4, (%rdi, %rcx) > - VMOVA VEC_SIZE(%rsi, %rcx), %YMM2 > - vpcmpb $0, %YMM2, %YMMZERO, %k0 > - kmovd %k0, %edx > - add $VEC_SIZE, %rcx > -# ifdef USE_AS_STRNCPY > - sub $VEC_SIZE, %r8 > - jbe L(CopyVecSizeCase2OrCase3) > -# endif > - test %edx, %edx > -# if defined USE_AS_STRNCPY && !defined USE_AS_STRCAT > - jnz L(CopyVecSizeUnalignedVec2) > -# else > - jnz L(CopyVecSize) > -# endif > > - VMOVU %YMM2, (%rdi, %rcx) > - VMOVA VEC_SIZE(%rsi, %rcx), %YMM2 > - vpcmpb $0, %YMM2, %YMMZERO, %k0 > - kmovd %k0, %edx > - add $VEC_SIZE, %rcx > -# ifdef USE_AS_STRNCPY > - sub $VEC_SIZE, %r8 > - jbe L(CopyVecSizeCase2OrCase3) > -# endif > - test %edx, %edx > -# if defined USE_AS_STRNCPY && !defined USE_AS_STRCAT > - jnz L(CopyVecSizeUnalignedVec2) > -# else > - jnz L(CopyVecSize) > -# endif > +# define PAGE_SIZE 4096 > +# define CHAR_PER_VEC (VEC_SIZE / CHAR_SIZE) > > - VMOVA VEC_SIZE(%rsi, %rcx), %YMM3 > - VMOVU %YMM2, (%rdi, %rcx) > - vpcmpb $0, %YMM3, %YMMZERO, %k0 > - kmovd %k0, %edx > - add $VEC_SIZE, %rcx > -# ifdef USE_AS_STRNCPY > - sub $VEC_SIZE, %r8 > - jbe L(CopyVecSizeCase2OrCase3) > -# endif > - test %edx, %edx > -# if defined USE_AS_STRNCPY && !defined USE_AS_STRCAT > - jnz L(CopyVecSizeUnalignedVec3) > -# else > - jnz L(CopyVecSize) > -# endif > > - VMOVU %YMM3, (%rdi, %rcx) > - mov %rsi, %rdx > - lea VEC_SIZE(%rsi, %rcx), %rsi > - and $-(VEC_SIZE * 4), %rsi > - sub %rsi, %rdx > - sub %rdx, %rdi > -# ifdef USE_AS_STRNCPY > - lea (VEC_SIZE * 8)(%r8, %rdx), %r8 > -# endif > -L(UnalignedFourVecSizeLoop): > - VMOVA (%rsi), %YMM4 > - VMOVA VEC_SIZE(%rsi), %YMM5 > - VMOVA (VEC_SIZE * 2)(%rsi), %YMM6 > - VMOVA (VEC_SIZE * 3)(%rsi), %YMM7 > - vpminub %YMM5, %YMM4, %YMM2 > - vpminub %YMM7, %YMM6, %YMM3 > - vpminub %YMM2, %YMM3, %YMM2 > - /* If K7 != 0, there is a null byte. */ > - vpcmpb $0, %YMM2, %YMMZERO, %k7 > - kmovd %k7, %edx > -# ifdef USE_AS_STRNCPY > - sub $(VEC_SIZE * 4), %r8 > - jbe L(UnalignedLeaveCase2OrCase3) > + .section SECTION(.text), "ax", @progbits > +ENTRY(STRCPY) > +# ifdef USE_AS_STRCAT > + movq %rdi, %rax > +# include "strcat-strlen-evex.S" > # endif > - test %edx, %edx > - jnz L(UnalignedFourVecSizeLeave) > - > -L(UnalignedFourVecSizeLoop_start): > - add $(VEC_SIZE * 4), %rdi > - add $(VEC_SIZE * 4), %rsi > - VMOVU %YMM4, -(VEC_SIZE * 4)(%rdi) > - VMOVA (%rsi), %YMM4 > - VMOVU %YMM5, -(VEC_SIZE * 3)(%rdi) > - VMOVA VEC_SIZE(%rsi), %YMM5 > - vpminub %YMM5, %YMM4, %YMM2 > - VMOVU %YMM6, -(VEC_SIZE * 2)(%rdi) > - VMOVA (VEC_SIZE * 2)(%rsi), %YMM6 > - VMOVU %YMM7, -VEC_SIZE(%rdi) > - VMOVA (VEC_SIZE * 3)(%rsi), %YMM7 > - vpminub %YMM7, %YMM6, %YMM3 > - vpminub %YMM2, %YMM3, %YMM2 > - /* If K7 != 0, there is a null byte. */ > - vpcmpb $0, %YMM2, %YMMZERO, %k7 > - kmovd %k7, %edx > -# ifdef USE_AS_STRNCPY > - sub $(VEC_SIZE * 4), %r8 > - jbe L(UnalignedLeaveCase2OrCase3) > + > + movl %esi, %PAGE_ALIGN_REG > + andl $(PAGE_SIZE - 1), %PAGE_ALIGN_REG > + cmpl $(PAGE_SIZE - VEC_SIZE), %PAGE_ALIGN_REG > + ja L(page_cross) > +L(page_cross_continue): > + VMOVU (%rsi), %VMM(0) > +# if !defined USE_AS_STPCPY && !defined USE_AS_STRCAT > + movq %rdi, %rax > # endif > - test %edx, %edx > - jz L(UnalignedFourVecSizeLoop_start) > > -L(UnalignedFourVecSizeLeave): > - vpcmpb $0, %YMM4, %YMMZERO, %k1 > - kmovd %k1, %edx > - test %edx, %edx > - jnz L(CopyVecSizeUnaligned_0) > > - vpcmpb $0, %YMM5, %YMMZERO, %k2 > - kmovd %k2, %ecx > - test %ecx, %ecx > - jnz L(CopyVecSizeUnaligned_16) > + /* Two short string implementations. One with traditional > + branching approach and one with masked instructions (which > + have potential for dramatically bad perf if dst splits a > + page and is not in the TLB). */ > +# if USE_EVEX_MASKED_STORE > + VPTEST %VMM(0), %VMM(0), %k0 > + KMOV %k0, %VRCX > +# ifdef USE_AS_WCSCPY > + subl $((1 << CHAR_PER_VEC)- 1), %VRCX > +# else > + inc %VRCX > +# endif > + jz L(more_1x_vec) > + KMOV %VRCX, %k1 > + KXOR %k0, %k1, %k1 > > - vpcmpb $0, %YMM6, %YMMZERO, %k3 > - kmovd %k3, %edx > - test %edx, %edx > - jnz L(CopyVecSizeUnaligned_32) > - > - vpcmpb $0, %YMM7, %YMMZERO, %k4 > - kmovd %k4, %ecx > - bsf %ecx, %edx > - VMOVU %YMM4, (%rdi) > - VMOVU %YMM5, VEC_SIZE(%rdi) > - VMOVU %YMM6, (VEC_SIZE * 2)(%rdi) > -# if defined USE_AS_STRNCPY && !defined USE_AS_STRCAT > -# ifdef USE_AS_STPCPY > - lea (VEC_SIZE * 3)(%rdi, %rdx), %rax > -# endif > - VMOVU %YMM7, (VEC_SIZE * 3)(%rdi) > - add $(VEC_SIZE - 1), %r8 > - sub %rdx, %r8 > - lea ((VEC_SIZE * 3) + 1)(%rdi, %rdx), %rdi > - jmp L(StrncpyFillTailWithZero) > -# else > - add $(VEC_SIZE * 3), %rsi > - add $(VEC_SIZE * 3), %rdi > - jmp L(CopyVecSizeExit) > -# endif > + VMOVU_MASK %VMM(0), (%rdi){%k1} > > -/* If source address alignment == destination address alignment */ > +# ifdef USE_AS_STPCPY > + bsf %VRCX, %VRCX > + leaq (%rdi, %rcx, CHAR_SIZE), %rax > +# endif > + ret > > -L(SourceStringAlignmentLessTwoVecSize): > - VMOVU (%rsi), %YMM3 > - VMOVU VEC_SIZE(%rsi), %YMM2 > - vpcmpb $0, %YMM3, %YMMZERO, %k0 > - kmovd %k0, %edx > +# else > + VPTESTN %VMM(0), %VMM(0), %k0 > + KMOV %k0, %VRCX > + test %VRCX, %VRCX > + jz L(more_1x_vec) > > -# ifdef USE_AS_STRNCPY > -# if defined USE_AS_STPCPY || defined USE_AS_STRCAT > - cmp $VEC_SIZE, %r8 > + xorl %edx, %edx > + bsf %VRCX, %VRDX > +# ifdef USE_AS_STPCPY > + leaq (%rdi, %rdx, CHAR_SIZE), %rax > +# endif > + > + /* Use mask bits in rcx to detect which copy we need. If the low > + mask is zero then there must be a bit set in the upper half. > + I.e if rcx != 0 and ecx == 0, then match must be upper 32 > + bits so we use L(copy_32_63). */ > +# if VEC_SIZE == 64 > +# ifdef USE_AS_WCSCPY > + testb %cl, %cl > +# else > + testl %ecx, %ecx > +# endif > + jz L(copy_32_63) > +# endif > + > +# ifdef USE_AS_WCSCPY > + testb $0xf, %cl > # else > - cmp $(VEC_SIZE + 1), %r8 > + testw %cx, %cx > # endif > - jbe L(CopyVecSizeTail1Case2OrCase3) > -# endif > - test %edx, %edx > - jnz L(CopyVecSizeTail1) > + jz L(copy_16_31) > > - VMOVU %YMM3, (%rdi) > - vpcmpb $0, %YMM2, %YMMZERO, %k0 > - kmovd %k0, %edx > > -# ifdef USE_AS_STRNCPY > -# if defined USE_AS_STPCPY || defined USE_AS_STRCAT > - cmp $(VEC_SIZE * 2), %r8 > +# ifdef USE_AS_WCSCPY > + testb $0x3, %cl > # else > - cmp $((VEC_SIZE * 2) + 1), %r8 > + testb %cl, %cl > # endif > - jbe L(CopyTwoVecSize1Case2OrCase3) > -# endif > - test %edx, %edx > - jnz L(CopyTwoVecSize1) > - > - and $-VEC_SIZE, %rsi > - and $(VEC_SIZE - 1), %ecx > - jmp L(UnalignVecSizeBoth) > + jz L(copy_8_15) > > -/*------End of main part with loops---------------------*/ > > -/* Case1 */ > +# ifdef USE_AS_WCSCPY > + vmovd %VMM_128(0), (%rdi) > + /* No need to copy, we know its zero. */ > + movl $0, (%END_REG) > > -# if (!defined USE_AS_STRNCPY) || (defined USE_AS_STRCAT) > - .p2align 4 > -L(CopyVecSize): > - add %rcx, %rdi > -# endif > -L(CopyVecSizeTail): > - add %rcx, %rsi > -L(CopyVecSizeTail1): > - bsf %edx, %edx > -L(CopyVecSizeExit): > - cmp $32, %edx > - jae L(Exit32_63) > - cmp $16, %edx > - jae L(Exit16_31) > - cmp $8, %edx > - jae L(Exit8_15) > - cmp $4, %edx > - jae L(Exit4_7) > - cmp $3, %edx > - je L(Exit3) > - cmp $1, %edx > - ja L(Exit2) > - je L(Exit1) > - movb $0, (%rdi) > -# ifdef USE_AS_STPCPY > - lea (%rdi), %rax > -# endif > -# if defined USE_AS_STRNCPY && !defined USE_AS_STRCAT > - sub $1, %r8 > - lea 1(%rdi), %rdi > - jnz L(StrncpyFillTailWithZero) > -# endif > ret > +# else > > - .p2align 4 > -L(CopyTwoVecSize1): > - add $VEC_SIZE, %rsi > - add $VEC_SIZE, %rdi > -# if defined USE_AS_STRNCPY && !defined USE_AS_STRCAT > - sub $VEC_SIZE, %r8 > -# endif > - jmp L(CopyVecSizeTail1) > - > - .p2align 4 > -L(CopyTwoVecSize): > - bsf %edx, %edx > - add %rcx, %rsi > - add $VEC_SIZE, %edx > - sub %ecx, %edx > - jmp L(CopyVecSizeExit) > - > - .p2align 4 > -L(CopyVecSizeUnaligned_0): > - bsf %edx, %edx > -# if defined USE_AS_STRNCPY && !defined USE_AS_STRCAT > -# ifdef USE_AS_STPCPY > - lea (%rdi, %rdx), %rax > -# endif > - VMOVU %YMM4, (%rdi) > - add $((VEC_SIZE * 4) - 1), %r8 > - sub %rdx, %r8 > - lea 1(%rdi, %rdx), %rdi > - jmp L(StrncpyFillTailWithZero) > -# else > - jmp L(CopyVecSizeExit) > -# endif > + testb $0x7, %cl > + jz L(copy_4_7) > > - .p2align 4 > -L(CopyVecSizeUnaligned_16): > - bsf %ecx, %edx > - VMOVU %YMM4, (%rdi) > -# if defined USE_AS_STRNCPY && !defined USE_AS_STRCAT > -# ifdef USE_AS_STPCPY > - lea VEC_SIZE(%rdi, %rdx), %rax > -# endif > - VMOVU %YMM5, VEC_SIZE(%rdi) > - add $((VEC_SIZE * 3) - 1), %r8 > - sub %rdx, %r8 > - lea (VEC_SIZE + 1)(%rdi, %rdx), %rdi > - jmp L(StrncpyFillTailWithZero) > -# else > - add $VEC_SIZE, %rsi > - add $VEC_SIZE, %rdi > - jmp L(CopyVecSizeExit) > -# endif > > - .p2align 4 > -L(CopyVecSizeUnaligned_32): > - bsf %edx, %edx > - VMOVU %YMM4, (%rdi) > - VMOVU %YMM5, VEC_SIZE(%rdi) > -# if defined USE_AS_STRNCPY && !defined USE_AS_STRCAT > -# ifdef USE_AS_STPCPY > - lea (VEC_SIZE * 2)(%rdi, %rdx), %rax > -# endif > - VMOVU %YMM6, (VEC_SIZE * 2)(%rdi) > - add $((VEC_SIZE * 2) - 1), %r8 > - sub %rdx, %r8 > - lea ((VEC_SIZE * 2) + 1)(%rdi, %rdx), %rdi > - jmp L(StrncpyFillTailWithZero) > -# else > - add $(VEC_SIZE * 2), %rsi > - add $(VEC_SIZE * 2), %rdi > - jmp L(CopyVecSizeExit) > -# endif > + test %edx, %edx > + jz L(set_null_term) > > -# ifdef USE_AS_STRNCPY > -# ifndef USE_AS_STRCAT > - .p2align 4 > -L(CopyVecSizeUnalignedVec6): > - VMOVU %YMM6, (%rdi, %rcx) > - jmp L(CopyVecSizeVecExit) > - > - .p2align 4 > -L(CopyVecSizeUnalignedVec5): > - VMOVU %YMM5, (%rdi, %rcx) > - jmp L(CopyVecSizeVecExit) > - > - .p2align 4 > -L(CopyVecSizeUnalignedVec4): > - VMOVU %YMM4, (%rdi, %rcx) > - jmp L(CopyVecSizeVecExit) > - > - .p2align 4 > -L(CopyVecSizeUnalignedVec3): > - VMOVU %YMM3, (%rdi, %rcx) > - jmp L(CopyVecSizeVecExit) > + /* NB: make this `vmovw` if support for AVX512-FP16 is added. > + */ > + vmovd %VMM_128(0), %esi > + movw %si, (%rdi) > + > + .p2align 4,, 1 > +L(set_null_term): > + /* No need to copy, we know its zero. */ > + movb $0, (%END_REG) > + ret > # endif > > -/* Case2 */ > - > - .p2align 4 > -L(CopyVecSizeCase2): > - add $VEC_SIZE, %r8 > - add %rcx, %rdi > - add %rcx, %rsi > - bsf %edx, %edx > - cmp %r8d, %edx > - jb L(CopyVecSizeExit) > - jmp L(StrncpyExit) > - > - .p2align 4 > -L(CopyTwoVecSizeCase2): > - add %rcx, %rsi > - bsf %edx, %edx > - add $VEC_SIZE, %edx > - sub %ecx, %edx > - cmp %r8d, %edx > - jb L(CopyVecSizeExit) > - jmp L(StrncpyExit) > - > -L(CopyVecSizeTailCase2): > - add %rcx, %rsi > - bsf %edx, %edx > - cmp %r8d, %edx > - jb L(CopyVecSizeExit) > - jmp L(StrncpyExit) > - > -L(CopyVecSizeTail1Case2): > - bsf %edx, %edx > - cmp %r8d, %edx > - jb L(CopyVecSizeExit) > - jmp L(StrncpyExit) > - > -/* Case2 or Case3, Case3 */ > - > - .p2align 4 > -L(CopyVecSizeCase2OrCase3): > - test %rdx, %rdx > - jnz L(CopyVecSizeCase2) > -L(CopyVecSizeCase3): > - add $VEC_SIZE, %r8 > - add %rcx, %rdi > - add %rcx, %rsi > - jmp L(StrncpyExit) > - > - .p2align 4 > -L(CopyTwoVecSizeCase2OrCase3): > - test %rdx, %rdx > - jnz L(CopyTwoVecSizeCase2) > - add %rcx, %rsi > - jmp L(StrncpyExit) > - > - .p2align 4 > -L(CopyVecSizeTailCase2OrCase3): > - test %rdx, %rdx > - jnz L(CopyVecSizeTailCase2) > - add %rcx, %rsi > - jmp L(StrncpyExit) > - > - .p2align 4 > -L(CopyTwoVecSize1Case2OrCase3): > - add $VEC_SIZE, %rdi > - add $VEC_SIZE, %rsi > - sub $VEC_SIZE, %r8 > -L(CopyVecSizeTail1Case2OrCase3): > - test %rdx, %rdx > - jnz L(CopyVecSizeTail1Case2) > - jmp L(StrncpyExit) > +# if VEC_SIZE == 64 > + .p2align 4,, 6 > +L(copy_32_63): > + VMOVU -(32 - CHAR_SIZE)(%rsi, %rdx, CHAR_SIZE), %VMM_256(1) > + VMOVU %VMM_256(0), (%rdi) > + VMOVU %VMM_256(1), -(32 - CHAR_SIZE)(%END_REG) > + ret > +# endif > + > + > + .p2align 4,, 6 > +L(copy_16_31): > + /* Use xmm1 explicitly here as it won't require a `vzeroupper` > + and will save code size. */ > + vmovdqu -(16 - CHAR_SIZE)(%rsi, %rdx, CHAR_SIZE), %xmm1 > + VMOVU %VMM_128(0), (%rdi) > + vmovdqu %xmm1, -(16 - CHAR_SIZE)(%END_REG) > + ret > + > + .p2align 4,, 8 > +L(copy_8_15): > +# ifdef USE_AS_WCSCPY > + movl -(8 - CHAR_SIZE)(%rsi, %rdx, CHAR_SIZE), %ecx > +# else > + movq -(8 - CHAR_SIZE)(%rsi, %rdx, CHAR_SIZE), %rcx > +# endif > + vmovq %VMM_128(0), (%rdi) > + movq %rcx, -(8 - CHAR_SIZE)(%END_REG) > + ret > # endif > > -/*------------End labels regarding with copying 1-VEC_SIZE bytes--and 1-(VEC_SIZE*2) bytes----*/ > > - .p2align 4 > -L(Exit1): > - movzwl (%rsi), %edx > - mov %dx, (%rdi) > -# ifdef USE_AS_STPCPY > - lea 1(%rdi), %rax > +# ifndef USE_AS_WCSCPY > + .p2align 4,, 12 > +L(copy_4_7): > + movl -(4 - CHAR_SIZE)(%rsi, %rdx, CHAR_SIZE), %ecx > + vmovd %VMM_128(0), (%rdi) > + movl %ecx, -(4 - CHAR_SIZE)(%END_REG) > + ret > # endif > -# if defined USE_AS_STRNCPY && !defined USE_AS_STRCAT > - sub $2, %r8 > - lea 2(%rdi), %rdi > - jnz L(StrncpyFillTailWithZero) > + > + > + .p2align 4,, 8 > +L(more_1x_vec): > +# if defined USE_AS_STPCPY || defined USE_AS_STRCAT > + VMOVU %VMM(0), (%rdi) > # endif > - ret > + subq %rsi, %rdi > + andq $-(VEC_SIZE), %rsi > + addq %rsi, %rdi > + VMOVA (VEC_SIZE * 1)(%rsi), %VMM(1) > > - .p2align 4 > -L(Exit2): > - movzwl (%rsi), %ecx > - mov %cx, (%rdi) > - movb $0, 2(%rdi) > + /* Ideally we store after moves to minimize impact of potential > + false-dependencies. */ > +# if !defined USE_AS_STPCPY && !defined USE_AS_STRCAT > + VMOVU %VMM(0), (%rax) > +# endif > + > + VPTESTN %VMM(1), %VMM(1), %k0 > + KMOV %k0, %VRCX > + test %VRCX, %VRCX > + jnz L(ret_vec_x1) > + > + VMOVA (VEC_SIZE * 2)(%rsi), %VMM(2) > + VMOVU %VMM(1), VEC_SIZE(%rdi) > + > + VPTESTN %VMM(2), %VMM(2), %k0 > + KMOV %k0, %VRCX > + test %VRCX, %VRCX > + jnz L(ret_vec_x2) > + > + VMOVA (VEC_SIZE * 3)(%rsi), %VMM(3) > + VMOVU %VMM(2), (VEC_SIZE * 2)(%rdi) > + > + VPTESTN %VMM(3), %VMM(3), %k0 > + KMOV %k0, %VRDX > + test %VRDX, %VRDX > + jnz L(ret_vec_x3) > + > + VMOVA (VEC_SIZE * 4)(%rsi), %VMM(4) > + VMOVU %VMM(3), (VEC_SIZE * 3)(%rdi) > + VPTESTN %VMM(4), %VMM(4), %k0 > + KMOV %k0, %VRCX > + test %VRCX, %VRCX > + jnz L(ret_vec_x4) > + > + VMOVU %VMM(4), (VEC_SIZE * 4)(%rdi) > + > + > + /* Align for 4x loop. */ > + subq %rsi, %rdi > + > + /* + VEC_SIZE * 5 because we never added the original VEC_SIZE > + we covered before aligning. */ > + subq $-(VEC_SIZE * 5), %rsi > + andq $-(VEC_SIZE * 4), %rsi > + > + > + /* Load first half of the loop before entry. */ > + VMOVA (VEC_SIZE * 0 + 0)(%rsi), %VMM(0) > + VMOVA (VEC_SIZE * 1 + 0)(%rsi), %VMM(1) > + VMOVA (VEC_SIZE * 2 + 0)(%rsi), %VMM(2) > + VMOVA (VEC_SIZE * 3 + 0)(%rsi), %VMM(3) > + > + VPMIN %VMM(0), %VMM(1), %VMM(4) > + VPMIN %VMM(2), %VMM(3), %VMM(6) > + VPTESTN %VMM(4), %VMM(4), %k2 > + VPTESTN %VMM(6), %VMM(6), %k4 > + KORTEST %k2, %k4 > + jnz L(loop_4x_done) > + > + .p2align 4,, 11 > +L(loop_4x_vec): > + > + VMOVU %VMM(0), (VEC_SIZE * 0 + 0)(%rdi, %rsi) > + VMOVU %VMM(1), (VEC_SIZE * 1 + 0)(%rdi, %rsi) > + VMOVU %VMM(2), (VEC_SIZE * 2 + 0)(%rdi, %rsi) > + VMOVU %VMM(3), (VEC_SIZE * 3 + 0)(%rdi, %rsi) > + > + subq $(VEC_SIZE * -4), %rsi > + > + VMOVA (VEC_SIZE * 0 + 0)(%rsi), %VMM(0) > + VMOVA (VEC_SIZE * 1 + 0)(%rsi), %VMM(1) > + VMOVA (VEC_SIZE * 2 + 0)(%rsi), %VMM(2) > + VMOVA (VEC_SIZE * 3 + 0)(%rsi), %VMM(3) > + > + > + VPMIN %VMM(0), %VMM(1), %VMM(4) > + VPMIN %VMM(2), %VMM(3), %VMM(6) > + VPTESTN %VMM(4), %VMM(4), %k2 > + VPTESTN %VMM(6), %VMM(6), %k4 > + KORTEST %k2, %k4 > + jz L(loop_4x_vec) > + > +L(loop_4x_done): > + VPTESTN %VMM(0), %VMM(0), %k0 > + KMOV %k0, %VRCX > + /* Restore rdi (%rdi). */ > + addq %rsi, %rdi > + test %VRCX, %VRCX > + jnz L(ret_vec_x0_end) > + VMOVU %VMM(0), (VEC_SIZE * 0 + 0)(%rdi) > + > + KMOV %k2, %VRCX > + test %VRCX, %VRCX > + jnz L(ret_vec_x1) > + VMOVU %VMM(1), (VEC_SIZE * 1 + 0)(%rdi) > + > + VPTESTN %VMM(2), %VMM(2), %k0 > + KMOV %k0, %VRCX > + test %VRCX, %VRCX > + jnz L(ret_vec_x2) > + VMOVU %VMM(2), (VEC_SIZE * 2 + 0)(%rdi) > + /* Place L(ret_vec_x4) here to save code size. We get a > + meaningfuly benefit doing this for stpcpy. */ > + KMOV %k4, %VRDX > +L(ret_vec_x3): > + bsf %VRDX, %VRDX > + VMOVU ((VEC_SIZE * 3)-(VEC_SIZE - CHAR_SIZE))(%rsi, %rdx, CHAR_SIZE), %VMM(0) > + VMOVU %VMM(0), ((VEC_SIZE * 3 + 0)-(VEC_SIZE - CHAR_SIZE))(%rdi, %rdx, CHAR_SIZE) > # ifdef USE_AS_STPCPY > - lea 2(%rdi), %rax > -# endif > -# if defined USE_AS_STRNCPY && !defined USE_AS_STRCAT > - sub $3, %r8 > - lea 3(%rdi), %rdi > - jnz L(StrncpyFillTailWithZero) > + leaq (VEC_SIZE * 3 + 0)(%rdi, %rdx, CHAR_SIZE), %rax > # endif > +L(return_end): > ret > > - .p2align 4 > -L(Exit3): > - mov (%rsi), %edx > - mov %edx, (%rdi) > + .p2align 4,, 6 > +L(ret_vec_x0_end): > + bsf %VRCX, %VRCX > # ifdef USE_AS_STPCPY > - lea 3(%rdi), %rax > -# endif > -# if defined USE_AS_STRNCPY && !defined USE_AS_STRCAT > - sub $4, %r8 > - lea 4(%rdi), %rdi > - jnz L(StrncpyFillTailWithZero) > + leaq (%rdi, %rcx, CHAR_SIZE), %rax > # endif > + inc %VRCX > + VMOVU (-(VEC_SIZE))(%rsi, %rcx, CHAR_SIZE), %VMM(0) > + VMOVU %VMM(0), (-(VEC_SIZE))(%rdi, %rcx, CHAR_SIZE) > ret > > - .p2align 4 > -L(Exit4_7): > - mov (%rsi), %ecx > - mov %ecx, (%rdi) > - mov -3(%rsi, %rdx), %ecx > - mov %ecx, -3(%rdi, %rdx) > + .p2align 4,, 8 > +L(ret_vec_x1): > + bsf %VRCX, %VRCX > + VMOVU (VEC_SIZE -(VEC_SIZE - CHAR_SIZE))(%rsi, %rcx, CHAR_SIZE), %VMM(0) > + VMOVU %VMM(0), (VEC_SIZE -(VEC_SIZE - CHAR_SIZE))(%rdi, %rcx, CHAR_SIZE) > # ifdef USE_AS_STPCPY > - lea (%rdi, %rdx), %rax > -# endif > -# if defined USE_AS_STRNCPY && !defined USE_AS_STRCAT > - sub %rdx, %r8 > - sub $1, %r8 > - lea 1(%rdi, %rdx), %rdi > - jnz L(StrncpyFillTailWithZero) > + leaq VEC_SIZE(%rdi, %rcx, CHAR_SIZE), %rax > # endif > ret > > - .p2align 4 > -L(Exit8_15): > - mov (%rsi), %rcx > - mov -7(%rsi, %rdx), %r9 > - mov %rcx, (%rdi) > - mov %r9, -7(%rdi, %rdx) > + .p2align 4,, 4 > +L(ret_vec_x2): > + bsf %VRCX, %VRCX > + VMOVU ((VEC_SIZE * 2)-(VEC_SIZE - CHAR_SIZE))(%rsi, %rcx, CHAR_SIZE), %VMM(0) > + VMOVU %VMM(0), ((VEC_SIZE * 2)-(VEC_SIZE - CHAR_SIZE))(%rdi, %rcx, CHAR_SIZE) > # ifdef USE_AS_STPCPY > - lea (%rdi, %rdx), %rax > -# endif > -# if defined USE_AS_STRNCPY && !defined USE_AS_STRCAT > - sub %rdx, %r8 > - sub $1, %r8 > - lea 1(%rdi, %rdx), %rdi > - jnz L(StrncpyFillTailWithZero) > + leaq (VEC_SIZE * 2)(%rdi, %rcx, CHAR_SIZE), %rax > # endif > ret > > - .p2align 4 > -L(Exit16_31): > - VMOVU (%rsi), %XMM2 > - VMOVU -15(%rsi, %rdx), %XMM3 > - VMOVU %XMM2, (%rdi) > - VMOVU %XMM3, -15(%rdi, %rdx) > + /* ret_vec_x3 reuses return code after the loop. */ > + .p2align 4,, 6 > +L(ret_vec_x4): > + bsf %VRCX, %VRCX > + VMOVU ((VEC_SIZE * 4)-(VEC_SIZE - CHAR_SIZE))(%rsi, %rcx, CHAR_SIZE), %VMM(0) > + VMOVU %VMM(0), ((VEC_SIZE * 4)-(VEC_SIZE - CHAR_SIZE))(%rdi, %rcx, CHAR_SIZE) > # ifdef USE_AS_STPCPY > - lea (%rdi, %rdx), %rax > -# endif > -# if defined USE_AS_STRNCPY && !defined USE_AS_STRCAT > - sub %rdx, %r8 > - sub $1, %r8 > - lea 1(%rdi, %rdx), %rdi > - jnz L(StrncpyFillTailWithZero) > + leaq (VEC_SIZE * 4)(%rdi, %rcx, CHAR_SIZE), %rax > # endif > ret > > - .p2align 4 > -L(Exit32_63): > - VMOVU (%rsi), %YMM2 > - VMOVU -31(%rsi, %rdx), %YMM3 > - VMOVU %YMM2, (%rdi) > - VMOVU %YMM3, -31(%rdi, %rdx) > -# ifdef USE_AS_STPCPY > - lea (%rdi, %rdx), %rax > + > + .p2align 4,, 4 > +L(page_cross): > +# ifndef USE_AS_STRCAT > + vpxorq %VZERO_128, %VZERO_128, %VZERO_128 > # endif > -# if defined USE_AS_STRNCPY && !defined USE_AS_STRCAT > - sub %rdx, %r8 > - sub $1, %r8 > - lea 1(%rdi, %rdx), %rdi > - jnz L(StrncpyFillTailWithZero) > + movq %rsi, %rcx > + andq $(VEC_SIZE * -1), %rcx > + > + VPCMPEQ (%rcx), %VZERO, %k0 > + KMOV %k0, %VRCX > +# ifdef USE_AS_WCSCPY > + andl $(VEC_SIZE - 1), %PAGE_ALIGN_REG > + shrl $2, %PAGE_ALIGN_REG > # endif > - ret > + shrx %VGPR(PAGE_ALIGN_REG_64), %VRCX, %VRCX > > -# ifdef USE_AS_STRNCPY > +# if USE_MOVSB_IN_PAGE_CROSS > + /* Optimizing more aggressively for space as this is very cold > + code. This saves 2x cache lines. */ > > - .p2align 4 > -L(StrncpyExit1): > - movzbl (%rsi), %edx > - mov %dl, (%rdi) > -# ifdef USE_AS_STPCPY > - lea 1(%rdi), %rax > -# endif > -# ifdef USE_AS_STRCAT > - movb $0, 1(%rdi) > + /* This adds once to the later result which will get correct > + copy bounds. NB: this can never zero-out a non-zero RCX as > + to be in the page cross case rsi cannot be aligned and we > + already right-shift rcx by the misalignment. */ > + shl %VRCX > + jz L(page_cross_continue) > +# if !defined USE_AS_STPCPY && !defined USE_AS_STRCAT > + movq %rdi, %rax > # endif > - ret > + bsf %VRCX, %VRCX > + REP_MOVS > > - .p2align 4 > -L(StrncpyExit2): > - movzwl (%rsi), %edx > - mov %dx, (%rdi) > # ifdef USE_AS_STPCPY > - lea 2(%rdi), %rax > -# endif > -# ifdef USE_AS_STRCAT > - movb $0, 2(%rdi) > + leaq -CHAR_SIZE(%rdi), %rax > # endif > ret > > - .p2align 4 > -L(StrncpyExit3_4): > - movzwl (%rsi), %ecx > - movzwl -2(%rsi, %r8), %edx > - mov %cx, (%rdi) > - mov %dx, -2(%rdi, %r8) > -# ifdef USE_AS_STPCPY > - lea (%rdi, %r8), %rax > -# endif > -# ifdef USE_AS_STRCAT > - movb $0, (%rdi, %r8) > -# endif > - ret > > - .p2align 4 > -L(StrncpyExit5_8): > - mov (%rsi), %ecx > - mov -4(%rsi, %r8), %edx > - mov %ecx, (%rdi) > - mov %edx, -4(%rdi, %r8) > -# ifdef USE_AS_STPCPY > - lea (%rdi, %r8), %rax > -# endif > -# ifdef USE_AS_STRCAT > - movb $0, (%rdi, %r8) > -# endif > - ret > +# else > + /* Check if we found zero-char before end of page. */ > + test %VRCX, %VRCX > + jz L(page_cross_continue) > > - .p2align 4 > -L(StrncpyExit9_16): > - mov (%rsi), %rcx > - mov -8(%rsi, %r8), %rdx > - mov %rcx, (%rdi) > - mov %rdx, -8(%rdi, %r8) > -# ifdef USE_AS_STPCPY > - lea (%rdi, %r8), %rax > -# endif > -# ifdef USE_AS_STRCAT > - movb $0, (%rdi, %r8) > -# endif > - ret > + /* Traditional copy case, essentially same as used in non-page- > + cross case but since we can't reuse VMM(0) we need twice as > + many loads from rsi. */ > > - .p2align 4 > -L(StrncpyExit17_32): > - VMOVU (%rsi), %XMM2 > - VMOVU -16(%rsi, %r8), %XMM3 > - VMOVU %XMM2, (%rdi) > - VMOVU %XMM3, -16(%rdi, %r8) > -# ifdef USE_AS_STPCPY > - lea (%rdi, %r8), %rax > -# endif > -# ifdef USE_AS_STRCAT > - movb $0, (%rdi, %r8) > +# ifndef USE_AS_STRCAT > + xorl %edx, %edx > # endif > - ret > - > - .p2align 4 > -L(StrncpyExit33_64): > - /* 0/32, 31/16 */ > - VMOVU (%rsi), %YMM2 > - VMOVU -VEC_SIZE(%rsi, %r8), %YMM3 > - VMOVU %YMM2, (%rdi) > - VMOVU %YMM3, -VEC_SIZE(%rdi, %r8) > + /* Dependency on rdi must already have been satisfied. */ > + bsf %VRCX, %VRDX > # ifdef USE_AS_STPCPY > - lea (%rdi, %r8), %rax > + leaq (%rdi, %rdx, CHAR_SIZE), %rax > +# elif !defined USE_AS_STRCAT > + movq %rdi, %rax > # endif > -# ifdef USE_AS_STRCAT > - movb $0, (%rdi, %r8) > -# endif > - ret > > - .p2align 4 > -L(StrncpyExit65): > - /* 0/32, 32/32, 64/1 */ > - VMOVU (%rsi), %YMM2 > - VMOVU 32(%rsi), %YMM3 > - mov 64(%rsi), %cl > - VMOVU %YMM2, (%rdi) > - VMOVU %YMM3, 32(%rdi) > - mov %cl, 64(%rdi) > -# ifdef USE_AS_STPCPY > - lea 65(%rdi), %rax > -# endif > -# ifdef USE_AS_STRCAT > - movb $0, 65(%rdi) > +# if VEC_SIZE == 64 > +# ifdef USE_AS_WCSCPY > + testb %cl, %cl > +# else > + test %ecx, %ecx > +# endif > + jz L(page_cross_copy_32_63) > # endif > - ret > - > -# ifndef USE_AS_STRCAT > > - .p2align 4 > -L(Fill1): > - mov %dl, (%rdi) > - ret > +# ifdef USE_AS_WCSCPY > + testb $0xf, %cl > +# else > + testw %cx, %cx > +# endif > + jz L(page_cross_copy_16_31) > > - .p2align 4 > -L(Fill2): > - mov %dx, (%rdi) > - ret > +# ifdef USE_AS_WCSCPY > + testb $0x3, %cl > +# else > + testb %cl, %cl > +# endif > + jz L(page_cross_copy_8_15) > > - .p2align 4 > -L(Fill3_4): > - mov %dx, (%rdi) > - mov %dx, -2(%rdi, %r8) > +# ifdef USE_AS_WCSCPY > + movl (%rsi), %esi > + movl %esi, (%rdi) > + movl $0, (%END_REG) > ret > +# else > > - .p2align 4 > -L(Fill5_8): > - mov %edx, (%rdi) > - mov %edx, -4(%rdi, %r8) > - ret > + testb $0x7, %cl > + jz L(page_cross_copy_4_7) > > - .p2align 4 > -L(Fill9_16): > - mov %rdx, (%rdi) > - mov %rdx, -8(%rdi, %r8) > + test %edx, %edx > + jz L(page_cross_set_null_term) > + movzwl (%rsi), %ecx > + movw %cx, (%rdi) > +L(page_cross_set_null_term): > + movb $0, (%END_REG) > ret > > - .p2align 4 > -L(Fill17_32): > - VMOVU %XMMZERO, (%rdi) > - VMOVU %XMMZERO, -16(%rdi, %r8) > - ret > > - .p2align 4 > -L(CopyVecSizeUnalignedVec2): > - VMOVU %YMM2, (%rdi, %rcx) > - > - .p2align 4 > -L(CopyVecSizeVecExit): > - bsf %edx, %edx > - add $(VEC_SIZE - 1), %r8 > - add %rcx, %rdi > -# ifdef USE_AS_STPCPY > - lea (%rdi, %rdx), %rax > -# endif > - sub %rdx, %r8 > - lea 1(%rdi, %rdx), %rdi > - > - .p2align 4 > -L(StrncpyFillTailWithZero): > - xor %edx, %edx > - sub $VEC_SIZE, %r8 > - jbe L(StrncpyFillExit) > - > - VMOVU %YMMZERO, (%rdi) > - add $VEC_SIZE, %rdi > - > - mov %rdi, %rsi > - and $(VEC_SIZE - 1), %esi > - sub %rsi, %rdi > - add %rsi, %r8 > - sub $(VEC_SIZE * 4), %r8 > - jb L(StrncpyFillLessFourVecSize) > - > -L(StrncpyFillLoopVmovdqa): > - VMOVA %YMMZERO, (%rdi) > - VMOVA %YMMZERO, VEC_SIZE(%rdi) > - VMOVA %YMMZERO, (VEC_SIZE * 2)(%rdi) > - VMOVA %YMMZERO, (VEC_SIZE * 3)(%rdi) > - add $(VEC_SIZE * 4), %rdi > - sub $(VEC_SIZE * 4), %r8 > - jae L(StrncpyFillLoopVmovdqa) > - > -L(StrncpyFillLessFourVecSize): > - add $(VEC_SIZE * 2), %r8 > - jl L(StrncpyFillLessTwoVecSize) > - VMOVA %YMMZERO, (%rdi) > - VMOVA %YMMZERO, VEC_SIZE(%rdi) > - add $(VEC_SIZE * 2), %rdi > - sub $VEC_SIZE, %r8 > - jl L(StrncpyFillExit) > - VMOVA %YMMZERO, (%rdi) > - add $VEC_SIZE, %rdi > - jmp L(Fill) > - > - .p2align 4 > -L(StrncpyFillLessTwoVecSize): > - add $VEC_SIZE, %r8 > - jl L(StrncpyFillExit) > - VMOVA %YMMZERO, (%rdi) > - add $VEC_SIZE, %rdi > - jmp L(Fill) > - > - .p2align 4 > -L(StrncpyFillExit): > - add $VEC_SIZE, %r8 > -L(Fill): > - cmp $17, %r8d > - jae L(Fill17_32) > - cmp $9, %r8d > - jae L(Fill9_16) > - cmp $5, %r8d > - jae L(Fill5_8) > - cmp $3, %r8d > - jae L(Fill3_4) > - cmp $1, %r8d > - ja L(Fill2) > - je L(Fill1) > + .p2align 4,, 4 > +L(page_cross_copy_4_7): > + movl (%rsi), %ecx > + movl -(4 - CHAR_SIZE)(%rsi, %rdx, CHAR_SIZE), %esi > + movl %ecx, (%rdi) > + movl %esi, -(4 - CHAR_SIZE)(%END_REG) > ret > - > -/* end of ifndef USE_AS_STRCAT */ > # endif > > - .p2align 4 > -L(UnalignedLeaveCase2OrCase3): > - test %rdx, %rdx > - jnz L(UnalignedFourVecSizeLeaveCase2) > -L(UnalignedFourVecSizeLeaveCase3): > - lea (VEC_SIZE * 4)(%r8), %rcx > - and $-VEC_SIZE, %rcx > - add $(VEC_SIZE * 3), %r8 > - jl L(CopyVecSizeCase3) > - VMOVU %YMM4, (%rdi) > - sub $VEC_SIZE, %r8 > - jb L(CopyVecSizeCase3) > - VMOVU %YMM5, VEC_SIZE(%rdi) > - sub $VEC_SIZE, %r8 > - jb L(CopyVecSizeCase3) > - VMOVU %YMM6, (VEC_SIZE * 2)(%rdi) > - sub $VEC_SIZE, %r8 > - jb L(CopyVecSizeCase3) > - VMOVU %YMM7, (VEC_SIZE * 3)(%rdi) > -# ifdef USE_AS_STPCPY > - lea (VEC_SIZE * 4)(%rdi), %rax > -# endif > -# ifdef USE_AS_STRCAT > - movb $0, (VEC_SIZE * 4)(%rdi) > -# endif > +# if VEC_SIZE == 64 > + .p2align 4,, 4 > +L(page_cross_copy_32_63): > + VMOVU (%rsi), %VMM_256(0) > + VMOVU -(32 - CHAR_SIZE)(%rsi, %rdx, CHAR_SIZE), %VMM_256(1) > + VMOVU %VMM_256(0), (%rdi) > + VMOVU %VMM_256(1), -(32 - CHAR_SIZE)(%END_REG) > ret > - > - .p2align 4 > -L(UnalignedFourVecSizeLeaveCase2): > - xor %ecx, %ecx > - vpcmpb $0, %YMM4, %YMMZERO, %k1 > - kmovd %k1, %edx > - add $(VEC_SIZE * 3), %r8 > - jle L(CopyVecSizeCase2OrCase3) > - test %edx, %edx > -# ifndef USE_AS_STRCAT > - jnz L(CopyVecSizeUnalignedVec4) > -# else > - jnz L(CopyVecSize) > -# endif > - vpcmpb $0, %YMM5, %YMMZERO, %k2 > - kmovd %k2, %edx > - VMOVU %YMM4, (%rdi) > - add $VEC_SIZE, %rcx > - sub $VEC_SIZE, %r8 > - jbe L(CopyVecSizeCase2OrCase3) > - test %edx, %edx > -# ifndef USE_AS_STRCAT > - jnz L(CopyVecSizeUnalignedVec5) > -# else > - jnz L(CopyVecSize) > # endif > > - vpcmpb $0, %YMM6, %YMMZERO, %k3 > - kmovd %k3, %edx > - VMOVU %YMM5, VEC_SIZE(%rdi) > - add $VEC_SIZE, %rcx > - sub $VEC_SIZE, %r8 > - jbe L(CopyVecSizeCase2OrCase3) > - test %edx, %edx > -# ifndef USE_AS_STRCAT > - jnz L(CopyVecSizeUnalignedVec6) > -# else > - jnz L(CopyVecSize) > -# endif > - > - vpcmpb $0, %YMM7, %YMMZERO, %k4 > - kmovd %k4, %edx > - VMOVU %YMM6, (VEC_SIZE * 2)(%rdi) > - lea VEC_SIZE(%rdi, %rcx), %rdi > - lea VEC_SIZE(%rsi, %rcx), %rsi > - bsf %edx, %edx > - cmp %r8d, %edx > - jb L(CopyVecSizeExit) > -L(StrncpyExit): > - cmp $65, %r8d > - je L(StrncpyExit65) > - cmp $33, %r8d > - jae L(StrncpyExit33_64) > - cmp $17, %r8d > - jae L(StrncpyExit17_32) > - cmp $9, %r8d > - jae L(StrncpyExit9_16) > - cmp $5, %r8d > - jae L(StrncpyExit5_8) > - cmp $3, %r8d > - jae L(StrncpyExit3_4) > - cmp $1, %r8d > - ja L(StrncpyExit2) > - je L(StrncpyExit1) > -# ifdef USE_AS_STPCPY > - mov %rdi, %rax > -# endif > -# ifdef USE_AS_STRCAT > - movb $0, (%rdi) > -# endif > + .p2align 4,, 4 > +L(page_cross_copy_16_31): > + vmovdqu (%rsi), %xmm0 > + vmovdqu -(16 - CHAR_SIZE)(%rsi, %rdx, CHAR_SIZE), %xmm1 > + vmovdqu %xmm0, (%rdi) > + vmovdqu %xmm1, -(16 - CHAR_SIZE)(%END_REG) > ret > > - .p2align 4 > -L(ExitZero): > -# ifndef USE_AS_STRCAT > - mov %rdi, %rax > -# endif > + .p2align 4,, 4 > +L(page_cross_copy_8_15): > + movq (%rsi), %rcx > + movq -(8 - CHAR_SIZE)(%rsi, %rdx, CHAR_SIZE), %rsi > + movq %rcx, (%rdi) > + movq %rsi, -(8 - CHAR_SIZE)(%END_REG) > ret > - > -# endif > - > -# ifndef USE_AS_STRCAT > -END (STRCPY) > -# else > -END (STRCAT) > # endif > +END(STRCPY) > #endif > diff --git a/sysdeps/x86_64/multiarch/strncat-evex.S b/sysdeps/x86_64/multiarch/strncat-evex.S > index 203a19bf21..38dcbfa0ec 100644 > --- a/sysdeps/x86_64/multiarch/strncat-evex.S > +++ b/sysdeps/x86_64/multiarch/strncat-evex.S > @@ -1,7 +1,512 @@ > -#ifndef STRNCAT > -# define STRNCAT __strncat_evex > -#endif > +/* {wcs|str}ncat with 256/512-bit EVEX. > + Copyright (C) 2022 Free Software Foundation, Inc. > + This file is part of the GNU C Library. > + > + The GNU C Library is free software; you can redistribute it and/or > + modify it under the terms of the GNU Lesser General Public > + License as published by the Free Software Foundation; either > + version 2.1 of the License, or (at your option) any later version. > + > + The GNU C Library is distributed in the hope that it will be useful, > + but WITHOUT ANY WARRANTY; without even the implied warranty of > + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > + Lesser General Public License for more details. > + > + You should have received a copy of the GNU Lesser General Public > + License along with the GNU C Library; if not, see > + . */ > + > +#include > + > +#if ISA_SHOULD_BUILD (4) > + > + /* Use evex-masked stores for small sizes. Turned off at the > + moment. */ > +# define USE_EVEX_MASKED_STORE 0 > + > +# include > + > +# ifndef VEC_SIZE > +# include "x86-evex256-vecs.h" > +# endif > + > +# ifndef STRNCAT > +# define STRNCAT __strncat_evex > +# endif > + > + > +# ifdef USE_AS_WCSCPY > +# define VMOVU_MASK vmovdqu32 > +# define VPMIN vpminud > +# define VPTESTN vptestnmd > +# define VPTEST vptestmd > +# define VPCMPEQ vpcmpeqd > +# define CHAR_SIZE 4 > + > +# define REP_MOVS rep movsd > + > +# define VMASK_REG VR10 > +# define FIND_FIRST_ONE(src, dst) movl $CHAR_PER_VEC, %dst; bsf %src, %dst > + > +# define USE_WIDE_CHAR > +# else > +# define VMOVU_MASK vmovdqu8 > +# define VPMIN vpminub > +# define VPTESTN vptestnmb > +# define VPTEST vptestmb > +# define VPCMPEQ vpcmpeqb > +# define CHAR_SIZE 1 > + > +# define REP_MOVS rep movsb > + > +# define VMASK_REG VRCX > +# define FIND_FIRST_ONE(src, dst) tzcnt %src, %dst > + > +# endif > + > +# include "strncpy-or-cat-overflow-def.h" > + > +# include "reg-macros.h" > + > + > +# define VZERO VMM(7) > +# define VZERO_128 VMM_128(7) > + > +# define PAGE_SIZE 4096 > +# define CHAR_PER_VEC (VEC_SIZE / CHAR_SIZE) > + > + .section SECTION(.text), "ax", @progbits > +ENTRY(STRNCAT) > + movq %rdi, %rax > +# ifdef USE_AS_WCSCPY > + decq %rdx > + movq %rdx, %rcx > + shrq $56, %rcx > + jnz L(zero_len) > +# else > + decq %rdx > + jl L(zero_len) > +# endif > + > +# include "strcat-strlen-evex.S" > + > + movl %esi, %ecx > + andl $(PAGE_SIZE - 1), %ecx > + cmpl $(PAGE_SIZE - VEC_SIZE), %ecx > + ja L(page_cross) > +L(page_cross_continue): > + VMOVU (%rsi), %VMM(0) > + VPTESTN %VMM(0), %VMM(0), %k0 > + > + /* If USE_EVEX_MASK_STORE is enabled then we just handle length > + <= CHAR_PER_VEC with masked instructions (which have > + potential for dramatically bad perf if dst splits a page and > + is not in the TLB). */ > +# if USE_EVEX_MASKED_STORE > + KMOV %k0, %VRCX > + cmpq $CHAR_PER_VEC, %rdx > + jae L(more_1x_vec) > + bts %VRDX, %VRCX > +L(less_1x_vec_masked): > + blsmsk %VRCX, %VRCX > + > + KMOV %VRCX, %k1 > + VMOVU_MASK %VMM(0), (%rdi){%k1} > + ret > +# else > + KMOV %k0, %VMASK_REG > + /* tzcnt for strncat and `movl $CHAR_PER_VEC, %VRCX; bsf > + %VMASK_REG, %VRCX` for wcsncat. */ > + FIND_FIRST_ONE (VMASK_REG, VRCX) > + cmpq %rcx, %rdx > + jb L(less_1x_vec) > + > + /* If there were no zero-CHARs (rcx was zero before > + FIND_FIRST_ONE), then ecx will be $CHAR_PER_VEC. */ > + cmpl $CHAR_PER_VEC, %ecx > + je L(more_1x_vec) > + > + movl %ecx, %edx > + > +L(less_1x_vec): > +# if VEC_SIZE == 64 > + cmpl $(32 / CHAR_SIZE - 1), %edx > + jae L(copy_32_63) > +# endif > + > + cmpl $(16 / CHAR_SIZE - 1), %edx > + jae L(copy_16_31) > + > + > + cmpl $(8 / CHAR_SIZE - 1), %edx > + jae L(copy_8_15) > + > +# ifdef USE_AS_WCSCPY > + movl -(4 - CHAR_SIZE)(%rsi, %rdx, CHAR_SIZE), %ecx > + vmovd %VMM_128(0), (%rdi) > + movl %ecx, -(4 - CHAR_SIZE)(%rdi, %rdx, CHAR_SIZE) > + ret > +# else > + > + cmpl $3, %edx > + jae L(copy_4_7) > + > + movzbl (%rsi, %rdx), %ecx > + test %edx, %edx > + je L(set_null_term) > + > + /* NB: make this `vmovw` if support for AVX512-FP16 is added. > + */ > + movzwl (%rsi), %esi > + movw %si, (%rdi) > + > + > + .p2align 4,, 1 > +L(set_null_term): > + movb %cl, (%rdi, %rdx) > + ret > +# endif > + > +# if VEC_SIZE == 64 > + .p2align 4,, 6 > +L(copy_32_63): > + VMOVU -(32 - CHAR_SIZE)(%rsi, %rdx, CHAR_SIZE), %VMM_256(1) > + VMOVU %VMM_256(0), (%rdi) > + VMOVU %VMM_256(1), -(32 - CHAR_SIZE)(%rdi, %rdx, CHAR_SIZE) > + ret > +# endif > + .p2align 4,, 6 > +L(copy_16_31): > + /* Use xmm1 explicitly here as it won't require a `vzeroupper` > + and will save code size. */ > + vmovdqu -(16 - CHAR_SIZE)(%rsi, %rdx, CHAR_SIZE), %xmm1 > + VMOVU %VMM_128(0), (%rdi) > + vmovdqu %xmm1, -(16 - CHAR_SIZE)(%rdi, %rdx, CHAR_SIZE) > + ret > + > + .p2align 4,, 2 > +L(copy_8_15): > + movq -(8 - CHAR_SIZE)(%rsi, %rdx, CHAR_SIZE), %rcx > + vmovq %VMM_128(0), (%rdi) > + movq %rcx, -(8 - CHAR_SIZE)(%rdi, %rdx, CHAR_SIZE) > + ret > + > +# ifndef USE_AS_WCSCPY > + .p2align 4,, 12 > +L(copy_4_7): > + movl -(4 - CHAR_SIZE)(%rsi, %rdx, CHAR_SIZE), %ecx > + vmovd %VMM_128(0), (%rdi) > + movl %ecx, -(4 - CHAR_SIZE)(%rdi, %rdx, CHAR_SIZE) > + ret > +# endif > + > +# endif > + > + .p2align 4,, 8 > +L(more_1x_vec): > +# if USE_EVEX_MASKED_STORE > + test %VRCX, %VRCX > + jnz L(less_1x_vec_masked) > +# endif > + > + > + VMOVU %VMM(0), (%rdi) > > -#define USE_AS_STRNCAT > -#define STRCAT STRNCAT > -#include "strcat-evex.S" > + /* We are going to align rsi here so will need to be able to re- > + adjust rdi/rdx afterwords. NB: We filtered out huge lengths > + so rsi + rdx * CHAR_SIZE cannot overflow. */ > + > + leaq (VEC_SIZE * -1)(%rsi, %rdx, CHAR_SIZE), %rdx > + subq %rsi, %rdi > + andq $-(VEC_SIZE), %rsi > +L(loop_last_4x_vec): > + addq %rsi, %rdi > + subq %rsi, %rdx > +# ifdef USE_AS_WCSCPY > + shrq $2, %rdx > +# endif > + > + /* Will need this regardless. */ > + VMOVA (VEC_SIZE * 1)(%rsi), %VMM(1) > + VPTESTN %VMM(1), %VMM(1), %k0 > + KMOV %k0, %VMASK_REG > + > + cmpq $(CHAR_PER_VEC * 2 - 1), %rdx > + ja L(more_2x_vec) > + > +L(last_2x_vec): > + FIND_FIRST_ONE (VMASK_REG, VRCX) > + cmpl %ecx, %edx > + jb L(ret_vec_x1_len) > + > + /* If there were no zero-CHARs (rcx was zero before > + FIND_FIRST_ONE), then ecx will be $CHAR_PER_VEC. */ > + cmpl $CHAR_PER_VEC, %ecx > + jne L(ret_vec_x1) > + > + > + VMOVA (VEC_SIZE * 2)(%rsi), %VMM(2) > + VMOVU %VMM(1), (VEC_SIZE * 1)(%rdi) > + VPTESTN %VMM(2), %VMM(2), %k0 > + KMOV %k0, %VRCX > + > + /* wcsncat needs to mask edx (length) before `bts`. strncat does > + not as `bts` will naturally mask the bit-position to > + instruction length. */ > +# ifdef USE_AS_WCSCPY > + andl $(CHAR_PER_VEC - 1), %edx > +# endif > + bts %VRDX, %VRCX > +L(ret_vec_x2): > + bsf %VRCX, %VRCX > + VMOVU (VEC_SIZE * 2 -(VEC_SIZE - CHAR_SIZE))(%rsi, %rcx, CHAR_SIZE), %VMM(0) > + VMOVU %VMM(0), (VEC_SIZE * 2 -(VEC_SIZE - CHAR_SIZE))(%rdi, %rcx, CHAR_SIZE) > + ret > + > + .p2align 4,, 8 > +L(ret_vec_x1_len): > + movl %edx, %ecx > +L(ret_vec_x1): > + VMOVU (VEC_SIZE -(VEC_SIZE - CHAR_SIZE))(%rsi, %rcx, CHAR_SIZE), %VMM(0) > + VMOVU %VMM(0), (VEC_SIZE-(VEC_SIZE - CHAR_SIZE))(%rdi, %rcx, CHAR_SIZE) > + ret > + > + .p2align 4,, 4 > +L(zero_len): > + incq %rdx > + jne OVERFLOW_STRCAT > + ret > + > + .p2align 4,, 8 > +L(last_4x_vec): > + /* Seperate logic for CHAR_PER_VEC == 64 because we can do `andl > + $(CHAR_PER_VEC * 4 - 1), %edx` with less code size just > + using `movzbl`. */ > +# if CHAR_PER_VEC == 64 > + movzbl %dl, %edx > +# else > + andl $(CHAR_PER_VEC * 4 - 1), %edx > +# endif > + VMOVA (VEC_SIZE * 5)(%rsi), %VMM(1) > + VPTESTN %VMM(1), %VMM(1), %k0 > + KMOV %k0, %VMASK_REG > + subq $-(VEC_SIZE * 4), %rsi > + subq $-(VEC_SIZE * 4), %rdi > + cmpl $(CHAR_PER_VEC * 2 - 1), %edx > + jbe L(last_2x_vec) > + .p2align 4,, 8 > +L(more_2x_vec): > + /* L(ret_vec_x1) expects position already to be in rcx so use > + `bsf` to test zero. */ > + bsf %VMASK_REG, %VRCX > + jnz L(ret_vec_x1) > + > + VMOVA (VEC_SIZE * 2)(%rsi), %VMM(2) > + VMOVU %VMM(1), (VEC_SIZE * 1)(%rdi) > + VPTESTN %VMM(2), %VMM(2), %k0 > + KMOV %k0, %VRCX > + test %VRCX, %VRCX > + jnz L(ret_vec_x2) > + > + VMOVA (VEC_SIZE * 3)(%rsi), %VMM(3) > + VMOVU %VMM(2), (VEC_SIZE * 2)(%rdi) > + VPTESTN %VMM(3), %VMM(3), %k0 > + KMOV %k0, %VMASK_REG > + > + cmpq $(CHAR_PER_VEC * 4 - 1), %rdx > + ja L(more_4x_vec) > + > + /* Adjust length before going to L(ret_vec_x3_len) or > + L(ret_vec_x3). */ > + addl $(CHAR_PER_VEC * -2), %edx > + > + FIND_FIRST_ONE (VMASK_REG, VRCX) > + cmpl %ecx, %edx > + jb L(ret_vec_x3_len) > + > + /* If there were no zero-CHARs (rcx was zero before > + FIND_FIRST_ONE), then ecx will be $CHAR_PER_VEC. */ > + cmpl $CHAR_PER_VEC, %ecx > + jne L(ret_vec_x3) > + > + VMOVA (VEC_SIZE * 4)(%rsi), %VMM(4) > + VMOVU %VMM(3), (VEC_SIZE * 3)(%rdi) > + VPTESTN %VMM(4), %VMM(4), %k0 > + KMOV %k0, %VRCX > +# ifdef USE_AS_WCSCPY > + andl $(CHAR_PER_VEC - 1), %edx > +# endif > + bts %VRDX, %VRCX > + .p2align 4,, 6 > +L(ret_vec_x4): > + bsf %VRCX, %VRCX > + VMOVU ((VEC_SIZE * 4)-(VEC_SIZE - CHAR_SIZE))(%rsi, %rcx, CHAR_SIZE), %VMM(0) > + VMOVU %VMM(0), ((VEC_SIZE * 4)-(VEC_SIZE - CHAR_SIZE))(%rdi, %rcx, CHAR_SIZE) > + ret > + > + > + .p2align 4,, 8 > +L(ret_vec_x3_len): > + movl %edx, %ecx > +L(ret_vec_x3): > + VMOVU ((VEC_SIZE * 3)-(VEC_SIZE - CHAR_SIZE))(%rsi, %rcx, CHAR_SIZE), %VMM(0) > + VMOVU %VMM(0), ((VEC_SIZE * 3)-(VEC_SIZE - CHAR_SIZE))(%rdi, %rcx, CHAR_SIZE) > + ret > + > + > + .p2align 4,, 8 > +L(more_4x_vec): > + bsf %VMASK_REG, %VRCX > + jnz L(ret_vec_x3) > + > + VMOVA (VEC_SIZE * 4)(%rsi), %VMM(4) > + VMOVU %VMM(3), (VEC_SIZE * 3)(%rdi) > + VPTESTN %VMM(4), %VMM(4), %k0 > + KMOV %k0, %VRCX > + test %VRCX, %VRCX > + jnz L(ret_vec_x4) > + > + VMOVU %VMM(4), (VEC_SIZE * 4)(%rdi) > + > + /* Check if we are near the end before aligning. */ > + cmpq $(CHAR_PER_VEC * 8 - 1), %rdx > + jbe L(last_4x_vec) > + > + > + /* Add rsi to rdx (length) before aligning rsi. NB: Since we > + filtered out huge lengths this cannot overflow. */ > +# ifdef USE_AS_WCSCPY > + leaq (%rsi, %rdx, CHAR_SIZE), %rdx > +# else > + addq %rsi, %rdx > +# endif > + > + /* Subtract rsi from rdi before aligning (add back will have > + correct rdi for aligned rsi). */ > + subq %rsi, %rdi > + subq $-(VEC_SIZE * 5), %rsi > + andq $(VEC_SIZE * -4), %rsi > + > + /* Load first half of the loop before entry. */ > + VMOVA (VEC_SIZE * 0 + 0)(%rsi), %VMM(0) > + VMOVA (VEC_SIZE * 1 + 0)(%rsi), %VMM(1) > + VMOVA (VEC_SIZE * 2 + 0)(%rsi), %VMM(2) > + VMOVA (VEC_SIZE * 3 + 0)(%rsi), %VMM(3) > + > + VPMIN %VMM(0), %VMM(1), %VMM(4) > + VPMIN %VMM(2), %VMM(3), %VMM(6) > + VPTESTN %VMM(4), %VMM(4), %k2 > + VPTESTN %VMM(6), %VMM(6), %k4 > + > + /* Offset rsi by VEC_SIZE so that we can jump to > + L(loop_last_4x_vec). */ > + addq $-(VEC_SIZE), %rsi > + KORTEST %k2, %k4 > + jnz L(loop_4x_done) > + > + /* Store loop end in r9. */ > + leaq -(VEC_SIZE * 5 - CHAR_SIZE)(%rdx), %r9 > + > + .p2align 4,, 11 > +L(loop_4x_vec): > + VMOVU %VMM(0), (VEC_SIZE * 1 + 0)(%rdi, %rsi) > + VMOVU %VMM(1), (VEC_SIZE * 2 + 0)(%rdi, %rsi) > + VMOVU %VMM(2), (VEC_SIZE * 3 + 0)(%rdi, %rsi) > + VMOVU %VMM(3), (VEC_SIZE * 4 + 0)(%rdi, %rsi) > + > + subq $(VEC_SIZE * -4), %rsi > + cmpq %rsi, %r9 > + jbe L(loop_last_4x_vec) > + > + VMOVA (VEC_SIZE * 1 + 0)(%rsi), %VMM(0) > + VMOVA (VEC_SIZE * 2 + 0)(%rsi), %VMM(1) > + VMOVA (VEC_SIZE * 3 + 0)(%rsi), %VMM(2) > + VMOVA (VEC_SIZE * 4 + 0)(%rsi), %VMM(3) > + > + VPMIN %VMM(0), %VMM(1), %VMM(4) > + VPMIN %VMM(2), %VMM(3), %VMM(6) > + VPTESTN %VMM(4), %VMM(4), %k2 > + VPTESTN %VMM(6), %VMM(6), %k4 > + KORTEST %k2, %k4 > + jz L(loop_4x_vec) > + > +L(loop_4x_done): > + VPTESTN %VMM(0), %VMM(0), %k0 > + KMOV %k0, %VRCX > + /* Restore rdi (dst). */ > + addq %rsi, %rdi > + > + /* L(ret_vec_x1) expects rcx to have position of zero-CHAR so > + test with bsf. */ > + bsf %VRCX, %VRCX > + jnz L(ret_vec_x1) > + VMOVU %VMM(0), (VEC_SIZE * 1 + 0)(%rdi) > + > + KMOV %k2, %VRCX > + test %VRCX, %VRCX > + jnz L(ret_vec_x2) > + VMOVU %VMM(1), (VEC_SIZE * 2 + 0)(%rdi) > + > + VPTESTN %VMM(2), %VMM(2), %k0 > + KMOV %k0, %VRCX > + bsf %VRCX, %VRCX > + jnz L(ret_vec_x3) > + VMOVU %VMM(2), (VEC_SIZE * 3 + 0)(%rdi) > + > + KMOV %k4, %VRDX > + bsf %VRDX, %VRDX > + VMOVU ((VEC_SIZE * 4)-(VEC_SIZE - CHAR_SIZE))(%rsi, %rdx, CHAR_SIZE), %VMM(0) > + VMOVU %VMM(0), ((VEC_SIZE * 4 + 0)-(VEC_SIZE - CHAR_SIZE))(%rdi, %rdx, CHAR_SIZE) > +L(return_end): > + ret > + > + .p2align 4,, 4 > + .p2align 6,, 8 > +L(page_cross): > + movq %rsi, %r8 > + andq $(VEC_SIZE * -1), %r8 > + VPCMPEQ (%r8), %VZERO, %k0 > + > +# ifdef USE_AS_WCSCPY > + KMOV %k0, %VR9 > + shrl $2, %ecx > + andl $(CHAR_PER_VEC - 1), %ecx > + shrx %VRCX, %VR9, %VRCX > +# else > + KMOV %k0, %VRCX > + shrx %VRSI, %VRCX, %VRCX > +# endif > + > + subl %esi, %r8d > + andl $(VEC_SIZE - 1), %r8d > +# ifdef USE_AS_WCSCPY > + shrl $2, %r8d > +# endif > + cmpq %r8, %rdx > + jb L(page_cross_small) > + /* Optimizing more for space as this is very cold code. This > + saves 2x cache lines. */ > + > + /* This adds once to the later result which will get correct > + copy bounds. NB: this can never zero-out a non-zero RCX as > + to be in the page cross case rsi cannot be aligned and we > + already right-shift rcx by the misalignment. */ > + shl %VRCX > + jz L(page_cross_continue) > + bsf %VRCX, %VRCX > + REP_MOVS > + ret > + > +L(page_cross_small): > + tzcnt %VRCX, %VRCX > + cmpq %rdx, %rcx > + cmova %edx, %ecx > + incl %ecx > +# ifdef USE_AS_WCSCPY > + rep movsd > +# else > + rep movsb > +# endif > + ret > +END(STRNCAT) > +#endif > diff --git a/sysdeps/x86_64/multiarch/strncpy-evex.S b/sysdeps/x86_64/multiarch/strncpy-evex.S > index 1b3426d511..49eaf4cbd9 100644 > --- a/sysdeps/x86_64/multiarch/strncpy-evex.S > +++ b/sysdeps/x86_64/multiarch/strncpy-evex.S > @@ -1,7 +1,990 @@ > -#ifndef STRNCPY > -# define STRNCPY __strncpy_evex > -#endif > +/* {wcs|wcp|str|stp}ncpy with 256/512-bit EVEX instructions. > + Copyright (C) 2022 Free Software Foundation, Inc. > + This file is part of the GNU C Library. > + > + The GNU C Library is free software; you can redistribute it and/or > + modify it under the terms of the GNU Lesser General Public > + License as published by the Free Software Foundation; either > + version 2.1 of the License, or (at your option) any later version. > + > + The GNU C Library is distributed in the hope that it will be useful, > + but WITHOUT ANY WARRANTY; without even the implied warranty of > + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > + Lesser General Public License for more details. > + > + You should have received a copy of the GNU Lesser General Public > + License along with the GNU C Library; if not, see > + . */ > + > +#include > + > +#if ISA_SHOULD_BUILD (4) > + > + /* Use evex-masked stores for small sizes. Turned off at the > + moment. */ > +# define USE_EVEX_MASKED_STORE 0 > + > + > +# include > +# ifndef VEC_SIZE > +# include "x86-evex256-vecs.h" > +# endif > + > + > +# ifndef STRNCPY > +# define STRNCPY __strncpy_evex > +# endif > + > +# ifdef USE_AS_WCSCPY > +# define VMOVU_MASK vmovdqu32 > +# define VPCMPEQ vpcmpeqd > +# define VPMIN vpminud > +# define VPTESTN vptestnmd > +# define VPTEST vptestmd > +# define CHAR_SIZE 4 > + > +# define REP_MOVS rep movsd > +# define REP_STOS rep stosl > + > +# define USE_WIDE_CHAR > + > +# else > +# define VMOVU_MASK vmovdqu8 > +# define VPCMPEQ vpcmpeqb > +# define VPMIN vpminub > +# define VPTESTN vptestnmb > +# define VPTEST vptestmb > +# define CHAR_SIZE 1 > + > +# define REP_MOVS rep movsb > +# define REP_STOS rep stosb > +# endif > + > +# include "strncpy-or-cat-overflow-def.h" > + > +# define PAGE_SIZE 4096 > +# define CHAR_PER_VEC (VEC_SIZE / CHAR_SIZE) > + > +# include "reg-macros.h" > + > + > +# define VZERO VMM(7) > +# define VZERO_256 VMM_256(7) > +# define VZERO_128 VMM_128(7) > + > +# if VEC_SIZE == 64 > +# define VZERO_HALF VZERO_256 > +# else > +# define VZERO_HALF VZERO_128 > +# endif > + > + .section SECTION(.text), "ax", @progbits > +ENTRY(STRNCPY) > + /* Filter zero length strings and very long strings. Zero > + length strings just return, very long strings are handled by > + just running rep stos{b|l} to zero set (which will almost > + certainly segfault), if that succeeds then just calling > + OVERFLOW_STRCPY (strcpy, stpcpy, wcscpy, wcpcpy). */ > +# ifdef USE_AS_WCSCPY > + decq %rdx > + movq %rdx, %rax > + /* 56 is end of max supported address space. */ > + shr $56, %rax > + jnz L(zero_len) > +# else > + decq %rdx > + /* If the flag needs to become `jb` replace `dec` with `sub`. > + */ > + jl L(zero_len) > +# endif > + > + vpxorq %VZERO_128, %VZERO_128, %VZERO_128 > + movl %esi, %eax > + andl $(PAGE_SIZE - 1), %eax > + cmpl $(PAGE_SIZE - VEC_SIZE), %eax > + ja L(page_cross) > + > +L(page_cross_continue): > + VMOVU (%rsi), %VMM(0) > + VPTESTN %VMM(0), %VMM(0), %k0 > + KMOV %k0, %VRCX > + > + /* If no STPCPY just save end ahead of time. */ > +# ifndef USE_AS_STPCPY > + movq %rdi, %rax > +# endif > + > + > + cmpq $(CHAR_PER_VEC), %rdx > + > + /* If USE_EVEX_MASK_STORE is enabled then we just handle length > + <= CHAR_PER_VEC with masked instructions (which have > + potential for dramatically bad perf if dst splits a page and > + is not in the TLB). */ > +# if USE_EVEX_MASKED_STORE > + /* `jae` because length rdx is now length - 1. */ > + jae L(more_1x_vec) > + > + /* If there where multiple zero-CHAR matches in the first VEC, > + VRCX will be overset but thats fine since any oversets where > + at zero-positions anyways. */ > + > +# ifdef USE_AS_STPCPY > + tzcnt %VRCX, %VRAX > + cmpl %eax, %edx > + cmovb %edx, %eax > +# ifdef USE_AS_WCSCPY > + adcl $0, %eax > + leaq (%rdi, %rax, CHAR_SIZE), %rax > +# else > + adcq %rdi, %rax > +# endif > +# endif > + dec %VRCX > + > + /* Zero out all non-zero CHAR's after the first zero match. */ > + KMOV %VRCX, %k1 > + > + /* Use VZERO as destination so this can be reused for > + L(zfill_less_vec) (which if jumped to by subsequent logic > + will have zerod out VZERO. */ > + VMOVU_MASK %VMM(0), %VZERO{%k1}{z} > +L(zfill_less_vec): > + /* Get mask for what we need to set. */ > + incl %edx > + mov $-1, %VRCX > + bzhi %VRDX, %VRCX, %VRCX > + KMOV %VRCX, %k1 > + VMOVU_MASK %VZERO, (%rdi){%k1} > + ret > + > + .p2align 4,, 4 > +L(zero_len): > + cmpq $-1, %rdx > + jne L(best_effort_strncpy) > + movq %rdi, %rax > + ret > + > + .p2align 4,, 8 > +L(more_1x_vec): > +# else > + /* `jb` because length rdx is now length - 1. */ > + jb L(less_1x_vec) > +# endif > + > + > + /* This may overset but thats fine because we still need to zero > + fill. */ > + VMOVU %VMM(0), (%rdi) > + > + > + /* Length must be >= CHAR_PER_VEC so match here means we must > + zero-fill. */ > + test %VRCX, %VRCX > + jnz L(zfill) > + > + > + /* We are going to align rsi here so will need to be able to re- > + adjust rdi/rdx afterwords. NB: We filtered out huge lengths > + so rsi + rdx * CHAR_SIZE cannot overflow. */ > + leaq (VEC_SIZE * -1)(%rsi, %rdx, CHAR_SIZE), %rdx > + subq %rsi, %rdi > + andq $-(VEC_SIZE), %rsi > + > +L(loop_last_4x_vec): > + addq %rsi, %rdi > + subq %rsi, %rdx > +# ifdef USE_AS_WCSCPY > + shrq $2, %rdx > +# endif > + > + VMOVA (VEC_SIZE * 1)(%rsi), %VMM(1) > + VPTESTN %VMM(1), %VMM(1), %k0 > + KMOV %k0, %VRCX > + > + /* -1 because of the `dec %rdx` earlier. */ > + cmpq $(CHAR_PER_VEC * 2 - 1), %rdx > + ja L(more_2x_vec) > + > +L(last_2x_vec): > + /* This will be need to be computed no matter what. We do it > + ahead of time for CHAR_PER_VEC == 64 because we can't adjust > + the value of `tzcnt` with a shift. */ > +# if CHAR_PER_VEC == 64 > + tzcntq %rcx, %rcx > +# endif > + > + cmpl $(CHAR_PER_VEC), %edx > + jb L(ret_vec_x1_len) > + > + /* Seperate logic for CHAR_PER_VEC == 64 because we already did > + `tzcnt` on VRCX. */ > +# if CHAR_PER_VEC == 64 > + /* cl == CHAR_PER_VEC iff it was zero before the `tzcnt`. */ > + cmpb $CHAR_PER_VEC, %cl > + jnz L(ret_vec_x1_no_bsf) > +# else > + test %VRCX, %VRCX > + jnz L(ret_vec_x1) > +# endif > + > + > + > + VPCMPEQ (VEC_SIZE * 2)(%rsi), %VZERO, %k0 > + VMOVU %VMM(1), (VEC_SIZE * 1)(%rdi) > + KMOV %k0, %VRCX > + > +# if CHAR_PER_VEC < 64 > + /* This essentiallys adds CHAR_PER_VEC to computed result. */ > + shlq $CHAR_PER_VEC, %rcx > +# else > + tzcntq %rcx, %rcx > + addl $CHAR_PER_VEC, %ecx > +# endif > + > + .p2align 4,, 4 > +L(ret_vec_x1_len): > + /* If CHAR_PER_VEC < 64 we still need to tzcnt, otherwise it has > + already been done. */ > +# if CHAR_PER_VEC < 64 > + tzcntq %rcx, %rcx > +# endif > + cmpl %ecx, %edx > + jbe L(ret_vec_x1_len_no_zfill) > + /* Fall through (expectation) is copy len < buffer len. */ > + VMOVU %VZERO, ((VEC_SIZE)-(VEC_SIZE - CHAR_SIZE))(%rdi, %rdx, CHAR_SIZE) > +L(ret_vec_x1_len_no_zfill_mov): > + movl %ecx, %edx > +# ifdef USE_AS_STPCPY > + /* clear flags. */ > + xorl %ecx, %ecx > +# endif > +L(ret_vec_x1_len_no_zfill): > + VMOVU ((VEC_SIZE)-(VEC_SIZE - CHAR_SIZE))(%rsi, %rdx, CHAR_SIZE), %VMM(0) > + VMOVU %VMM(0), ((VEC_SIZE)-(VEC_SIZE - CHAR_SIZE))(%rdi, %rdx, CHAR_SIZE) > +# ifdef USE_AS_STPCPY > +# ifdef USE_AS_WCSCPY > + adcq $0, %rdx > + leaq (VEC_SIZE * 1)(%rdi, %rdx, CHAR_SIZE), %rax > +# else > + leal (VEC_SIZE)(%rdx), %eax > + adcq %rdi, %rax > +# endif > +# endif > + ret > + > + > + .p2align 4,, 10 > +L(ret_vec_x1): > + bsf %VRCX, %VRCX > +L(ret_vec_x1_no_bsf): > + VMOVU %VZERO, ((VEC_SIZE)-(VEC_SIZE - CHAR_SIZE))(%rdi, %rdx, CHAR_SIZE) > + subl %ecx, %edx > + cmpl $CHAR_PER_VEC, %edx > + jb L(ret_vec_x1_len_no_zfill_mov) > + /* Fall through (expectation) is copy len < buffer len. */ > + VMOVU %VMM(1), (VEC_SIZE * 1)(%rdi) > + VMOVU %VZERO, (VEC_SIZE * 1)(%rdi, %rcx, CHAR_SIZE) > +# ifdef USE_AS_STPCPY > + leaq (VEC_SIZE * 1)(%rdi, %rcx, CHAR_SIZE), %rax > +# endif > + ret > + > + .p2align 4,, 8 > +L(last_4x_vec): > + /* Seperate logic for CHAR_PER_VEC == 64 because we can do `andl > + $(CHAR_PER_VEC * 4 - 1), %edx` with less code size just > + using `movzbl`. */ > +# if CHAR_PER_VEC == 64 > + movzbl %dl, %edx > +# else > + andl $(CHAR_PER_VEC * 4 - 1), %edx > +# endif > + VMOVA (VEC_SIZE * 5)(%rsi), %VMM(1) > + VPTESTN %VMM(1), %VMM(1), %k0 > + KMOV %k0, %VRCX > + subq $-(VEC_SIZE * 4), %rsi > + subq $-(VEC_SIZE * 4), %rdi > + cmpl $(CHAR_PER_VEC * 2 - 1), %edx > + jbe L(last_2x_vec) > + .p2align 4,, 8 > +L(more_2x_vec): > + VMOVU %VMM(1), (VEC_SIZE * 1)(%rdi) > + test %VRCX, %VRCX > + /* Must fill at least 2x VEC. */ > + jnz L(zfill_vec1) > + > + VMOVA (VEC_SIZE * 2)(%rsi), %VMM(2) > + VMOVU %VMM(2), (VEC_SIZE * 2)(%rdi) > + VPTESTN %VMM(2), %VMM(2), %k0 > + KMOV %k0, %VRCX > + test %VRCX, %VRCX > + /* Must fill at least 1x VEC. */ > + jnz L(zfill_vec2) > + > + VMOVA (VEC_SIZE * 3)(%rsi), %VMM(3) > + VPTESTN %VMM(3), %VMM(3), %k0 > + KMOV %k0, %VRCX > + > + /* Check if len is more 4x VEC. -1 because rdx is len - 1. */ > + cmpq $(CHAR_PER_VEC * 4 - 1), %rdx > + ja L(more_4x_vec) > + > + subl $(CHAR_PER_VEC * 3), %edx > + jb L(ret_vec_x3_len) > + > + test %VRCX, %VRCX > + jnz L(ret_vec_x3) > + > + VPCMPEQ (VEC_SIZE * 4)(%rsi), %VZERO, %k0 > + VMOVU %VMM(3), (VEC_SIZE * 3)(%rdi) > + KMOV %k0, %VRCX > + tzcnt %VRCX, %VRCX > + cmpl %ecx, %edx > + jbe L(ret_vec_x4_len_no_zfill) > + /* Fall through (expectation) is copy len < buffer len. */ > + VMOVU %VZERO, ((VEC_SIZE * 4)-(VEC_SIZE - CHAR_SIZE))(%rdi, %rdx, CHAR_SIZE) > + movl %ecx, %edx > +L(ret_vec_x4_len_no_zfill): > + VMOVU ((VEC_SIZE * 4)-(VEC_SIZE - CHAR_SIZE))(%rsi, %rdx, CHAR_SIZE), %VMM(0) > + VMOVU %VMM(0), ((VEC_SIZE * 4)-(VEC_SIZE - CHAR_SIZE))(%rdi, %rdx, CHAR_SIZE) > +# ifdef USE_AS_STPCPY > +# ifdef USE_AS_WCSCPY > + adcq $0, %rdx > + leaq (VEC_SIZE * 4)(%rdi, %rdx, CHAR_SIZE), %rax > +# else > + leal (VEC_SIZE * 4 + 0)(%rdx), %eax > + adcq %rdi, %rax > +# endif > +# endif > + ret > + > + > +L(ret_vec_x3_len): > + addl $(CHAR_PER_VEC * 1), %edx > + tzcnt %VRCX, %VRCX > + cmpl %ecx, %edx > + jbe L(ret_vec_x3_len_no_zfill) > + /* Fall through (expectation) is copy len < buffer len. */ > + VMOVU %VZERO, ((VEC_SIZE * 3)-(VEC_SIZE - CHAR_SIZE))(%rdi, %rdx, CHAR_SIZE) > +L(ret_vec_x3_len_no_zfill_mov): > + movl %ecx, %edx > +# ifdef USE_AS_STPCPY > + /* clear flags. */ > + xorl %ecx, %ecx > +# endif > + .p2align 4,, 4 > +L(ret_vec_x3_len_no_zfill): > + VMOVU ((VEC_SIZE * 3)-(VEC_SIZE - CHAR_SIZE))(%rsi, %rdx, CHAR_SIZE), %VMM(0) > + VMOVU %VMM(0), ((VEC_SIZE * 3)-(VEC_SIZE - CHAR_SIZE))(%rdi, %rdx, CHAR_SIZE) > +# ifdef USE_AS_STPCPY > +# ifdef USE_AS_WCSCPY > + adcq $0, %rdx > + leaq (VEC_SIZE * 3)(%rdi, %rdx, CHAR_SIZE), %rax > +# else > + leal (VEC_SIZE * 3 + 0)(%rdx), %eax > + adcq %rdi, %rax > +# endif > +# endif > + ret > + > + > + .p2align 4,, 8 > +L(ret_vec_x3): > + bsf %VRCX, %VRCX > + VMOVU %VZERO, (VEC_SIZE * 4 +(-(VEC_SIZE - CHAR_SIZE)))(%rdi, %rdx, CHAR_SIZE) > + subl %ecx, %edx > + jl L(ret_vec_x3_len_no_zfill_mov) > + VMOVU %VMM(3), (VEC_SIZE * 3)(%rdi) > + VMOVU %VZERO, (VEC_SIZE * 3)(%rdi, %rcx, CHAR_SIZE) > +# ifdef USE_AS_STPCPY > + leaq (VEC_SIZE * 3)(%rdi, %rcx, CHAR_SIZE), %rax > +# endif > + ret > + > + .p2align 4,, 8 > +L(more_4x_vec): > + VMOVU %VMM(3), (VEC_SIZE * 3)(%rdi) > + test %VRCX, %VRCX > + jnz L(zfill_vec3) > + > + VMOVA (VEC_SIZE * 4)(%rsi), %VMM(4) > + VMOVU %VMM(4), (VEC_SIZE * 4)(%rdi) > + VPTESTN %VMM(4), %VMM(4), %k0 > + KMOV %k0, %VRCX > + test %VRCX, %VRCX > + jnz L(zfill_vec4) > > -#define USE_AS_STRNCPY > -#define STRCPY STRNCPY > -#include "strcpy-evex.S" > + /* Recheck length before aligning. */ > + cmpq $(CHAR_PER_VEC * 8 - 1), %rdx > + jbe L(last_4x_vec) > + > + /* Align rsi to VEC_SIZE * 4, need to readjust rdx / rdi. */ > +# ifdef USE_AS_WCSCPY > + leaq (%rsi, %rdx, CHAR_SIZE), %rdx > +# else > + addq %rsi, %rdx > +# endif > + subq %rsi, %rdi > + subq $-(VEC_SIZE * 5), %rsi > + andq $(VEC_SIZE * -4), %rsi > + > + > + /* Load first half of the loop before entry. */ > + VMOVA (VEC_SIZE * 0 + 0)(%rsi), %VMM(0) > + VMOVA (VEC_SIZE * 1 + 0)(%rsi), %VMM(1) > + VMOVA (VEC_SIZE * 2 + 0)(%rsi), %VMM(2) > + VMOVA (VEC_SIZE * 3 + 0)(%rsi), %VMM(3) > + > + VPMIN %VMM(0), %VMM(1), %VMM(4) > + VPMIN %VMM(2), %VMM(3), %VMM(6) > + VPTESTN %VMM(4), %VMM(4), %k2 > + VPTESTN %VMM(6), %VMM(6), %k4 > + > + > + /* Offset rsi by VEC_SIZE so that we can jump to > + L(loop_last_4x_vec). */ > + addq $-(VEC_SIZE), %rsi > + KORTEST %k2, %k4 > + jnz L(loop_4x_done) > + > + /* Store loop end in r9. */ > + leaq -(VEC_SIZE * 5 - CHAR_SIZE)(%rdx), %r9 > + > + .p2align 4,, 11 > +L(loop_4x_vec): > + VMOVU %VMM(0), (VEC_SIZE * 1 + 0)(%rdi, %rsi) > + VMOVU %VMM(1), (VEC_SIZE * 2 + 0)(%rdi, %rsi) > + VMOVU %VMM(2), (VEC_SIZE * 3 + 0)(%rdi, %rsi) > + VMOVU %VMM(3), (VEC_SIZE * 4 + 0)(%rdi, %rsi) > + > + subq $(VEC_SIZE * -4), %rsi > + cmpq %rsi, %r9 > + jbe L(loop_last_4x_vec) > + > + VMOVA (VEC_SIZE * 1 + 0)(%rsi), %VMM(0) > + VMOVA (VEC_SIZE * 2 + 0)(%rsi), %VMM(1) > + VMOVA (VEC_SIZE * 3 + 0)(%rsi), %VMM(2) > + VMOVA (VEC_SIZE * 4 + 0)(%rsi), %VMM(3) > + > + VPMIN %VMM(0), %VMM(1), %VMM(4) > + VPMIN %VMM(2), %VMM(3), %VMM(6) > + VPTESTN %VMM(4), %VMM(4), %k2 > + VPTESTN %VMM(6), %VMM(6), %k4 > + KORTEST %k2, %k4 > + jz L(loop_4x_vec) > + > +L(loop_4x_done): > + /* Restore rdx (length). */ > + subq %rsi, %rdx > +# ifdef USE_AS_WCSCPY > + shrq $2, %rdx > +# endif > + VMOVU %VMM(0), (VEC_SIZE * 1 + 0)(%rdi, %rsi) > + /* Restore rdi (dst). */ > + addq %rsi, %rdi > + VPTESTN %VMM(0), %VMM(0), %k0 > + KMOV %k0, %VRCX > + test %VRCX, %VRCX > + jnz L(zfill_vec1) > + > + VMOVU %VMM(1), (VEC_SIZE * 2 + 0)(%rdi) > + KMOV %k2, %VRCX > + test %VRCX, %VRCX > + jnz L(zfill_vec2) > + > + VMOVU %VMM(2), (VEC_SIZE * 3 + 0)(%rdi) > + VPTESTN %VMM(2), %VMM(2), %k0 > + KMOV %k0, %VRCX > + test %VRCX, %VRCX > + jnz L(zfill_vec3) > + > + VMOVU %VMM(3), (VEC_SIZE * 4 + 0)(%rdi) > + KMOV %k4, %VRCX > + // Zfill more.... > + > + .p2align 4,, 4 > +L(zfill_vec4): > + subq $(VEC_SIZE * -2), %rdi > + addq $(CHAR_PER_VEC * -2), %rdx > +L(zfill_vec2): > + subq $(VEC_SIZE * -2), %rdi > + addq $(CHAR_PER_VEC * -1), %rdx > +L(zfill): > + /* VRCX must be non-zero. */ > + bsf %VRCX, %VRCX > + > + /* Adjust length / dst for zfill. */ > + subq %rcx, %rdx > +# ifdef USE_AS_WCSCPY > + leaq (%rdi, %rcx, CHAR_SIZE), %rdi > +# else > + addq %rcx, %rdi > +# endif > +# ifdef USE_AS_STPCPY > + movq %rdi, %rax > +# endif > +L(zfill_from_page_cross): > + > + /* From here on out its just memset(rdi, 0, rdx). */ > + cmpq $CHAR_PER_VEC, %rdx > + jb L(zfill_less_vec) > + > +L(zfill_more_1x_vec): > + VMOVU %VZERO, (%rdi) > + VMOVU %VZERO, (CHAR_SIZE - VEC_SIZE)(%rdi, %rdx, CHAR_SIZE) > + cmpq $(CHAR_PER_VEC * 2 - 1), %rdx > + ja L(zfill_more_2x_vec) > +L(zfill_done0): > + ret > + > + /* Coming from vec1/vec2 we must be able to zfill at least 2x > + VEC. */ > + .p2align 4,, 8 > +L(zfill_vec3): > + subq $(VEC_SIZE * -2), %rdi > + addq $(CHAR_PER_VEC * -2), %rdx > + .p2align 4,, 2 > +L(zfill_vec1): > + bsfq %rcx, %rcx > + /* rdi is currently dst - VEC_SIZE so add back VEC_SIZE here. > + */ > + leaq VEC_SIZE(%rdi, %rcx, CHAR_SIZE), %rdi > + subq %rcx, %rdx > +# ifdef USE_AS_STPCPY > + movq %rdi, %rax > +# endif > + > + > + VMOVU %VZERO, (%rdi) > + VMOVU %VZERO, (CHAR_SIZE - VEC_SIZE)(%rdi, %rdx, CHAR_SIZE) > + cmpq $(CHAR_PER_VEC * 2), %rdx > + jb L(zfill_done0) > +L(zfill_more_2x_vec): > + VMOVU %VZERO, (CHAR_SIZE - VEC_SIZE * 2)(%rdi, %rdx, CHAR_SIZE) > + VMOVU %VZERO, (VEC_SIZE)(%rdi) > + subq $(CHAR_PER_VEC * 4 - 1), %rdx > + jbe L(zfill_done) > + > +# ifdef USE_AS_WCSCPY > + leaq (%rdi, %rdx, CHAR_SIZE), %rdx > +# else > + addq %rdi, %rdx > +# endif > + > + VMOVU %VZERO, (VEC_SIZE * 2)(%rdi) > + VMOVU %VZERO, (VEC_SIZE * 3)(%rdi) > + > + > + VMOVU %VZERO, (VEC_SIZE * 0 + 0)(%rdx) > + VMOVU %VZERO, (VEC_SIZE * 1 + 0)(%rdx) > + > + subq $-(VEC_SIZE * 4), %rdi > + cmpq %rdi, %rdx > + jbe L(zfill_done) > + > + /* Align rdi and zfill loop. */ > + andq $-(VEC_SIZE), %rdi > + .p2align 4,, 12 > +L(zfill_loop_4x_vec): > + VMOVA %VZERO, (VEC_SIZE * 0)(%rdi) > + VMOVA %VZERO, (VEC_SIZE * 1)(%rdi) > + VMOVA %VZERO, (VEC_SIZE * 2)(%rdi) > + VMOVA %VZERO, (VEC_SIZE * 3)(%rdi) > + subq $-(VEC_SIZE * 4), %rdi > + cmpq %rdi, %rdx > + ja L(zfill_loop_4x_vec) > +L(zfill_done): > + ret > + > + > + /* Less 1x VEC case if we are not using evex masked store. */ > +# if !USE_EVEX_MASKED_STORE > + .p2align 4,, 8 > +L(copy_1x): > + /* Special case for copy 1x. It can be handled quickly and many > + buffer sizes have convenient alignment. */ > + VMOVU %VMM(0), (%rdi) > + /* If no zeros then we are done. */ > + testl %ecx, %ecx > + jz L(ret_1x_1x) > + > + /* Need to zfill, not we know that length <= CHAR_PER_VEC so we > + only handle the small case here. */ > + bsf %VRCX, %VRCX > +L(zfill_less_vec_no_bsf): > + /* Adjust length / dst then just zfill less_vec. */ > + subq %rcx, %rdx > +# ifdef USE_AS_WCSCPY > + leaq (%rdi, %rcx, CHAR_SIZE), %rdi > +# else > + addq %rcx, %rdi > +# endif > +# ifdef USE_AS_STPCPY > + movq %rdi, %rax > +# endif > + > +L(zfill_less_vec): > + cmpl $((VEC_SIZE / 2) / CHAR_SIZE), %edx > + jb L(zfill_less_half) > + > + VMOVU %VZERO_HALF, (%rdi) > + VMOVU %VZERO_HALF, -((VEC_SIZE / 2)- CHAR_SIZE)(%rdi, %rdx, CHAR_SIZE) > + ret > +# ifdef USE_AS_STPCPY > +L(ret_1x_1x): > + leaq CHAR_SIZE(%rdi, %rdx, CHAR_SIZE), %rax > + ret > +# endif > + > + > +# if VEC_SIZE == 64 > + .p2align 4,, 4 > +L(copy_32_63): > + /* Overfill to avoid branches. */ > + VMOVU -(32 - CHAR_SIZE)(%rsi, %rdx, CHAR_SIZE), %VMM_256(1) > + VMOVU %VMM_256(0), (%rdi) > + VMOVU %VMM_256(1), -(32 - CHAR_SIZE)(%rdi, %rdx, CHAR_SIZE) > + > + /* We are taking advantage of the fact that to be here we must > + be writing null-term as (%rdi, %rcx) we have a byte of lee- > + way for overwriting. */ > + cmpl %ecx, %edx > + ja L(zfill_less_vec_no_bsf) > +# ifndef USE_AS_STPCPY > +L(ret_1x_1x): > +# else > +# ifdef USE_AS_WCSCPY > + adcq $0, %rdx > + leaq (%rdi, %rdx, CHAR_SIZE), %rax > +# else > + movl %edx, %eax > + adcq %rdi, %rax > +# endif > +# endif > + ret > +# endif > + > + .p2align 4,, 4 > +L(copy_16_31): > + /* Overfill to avoid branches. */ > + vmovdqu -(16 - CHAR_SIZE)(%rsi, %rdx, CHAR_SIZE), %xmm1 > + VMOVU %VMM_128(0), (%rdi) > + vmovdqu %xmm1, -(16 - CHAR_SIZE)(%rdi, %rdx, CHAR_SIZE) > + cmpl %ecx, %edx > + > + /* Seperate logic depending on VEC_SIZE. If VEC_SIZE == 64 then > + we have a larger copy block for 32-63 so this is just falls > + through to zfill 16-31. If VEC_SIZE == 32 then we check for > + full zfill of less 1x VEC. */ > +# if VEC_SIZE == 64 > + jbe L(ret_16_31) > + subl %ecx, %edx > +# ifdef USE_AS_WCSCPY > + leaq (%rdi, %rcx, CHAR_SIZE), %rdi > +# else > + addq %rcx, %rdi > +# endif > +# ifdef USE_AS_STPCPY > + movq %rdi, %rax > +# endif > +L(zfill_less_half): > +L(zfill_less_32): > + cmpl $(16 / CHAR_SIZE), %edx > + jb L(zfill_less_16) > + VMOVU %VZERO_128, (%rdi) > + VMOVU %VZERO_128, -(16 - CHAR_SIZE)(%rdi, %rdx, CHAR_SIZE) > +# ifdef USE_AS_STPCPY > + ret > +# endif > +L(ret_16_31): > +# ifdef USE_AS_STPCPY > +# ifdef USE_AS_WCSCPY > + adcq $0, %rdx > + leaq (%rdi, %rdx, CHAR_SIZE), %rax > +# else > + movl %edx, %eax > + adcq %rdi, %rax > +# endif > +# endif > + ret > +# else > + /* VEC_SIZE == 32 begins. */ > + ja L(zfill_less_vec_no_bsf) > +# ifndef USE_AS_STPCPY > +L(ret_1x_1x): > +# else > +# ifdef USE_AS_WCSCPY > + adcq $0, %rdx > + leaq (%rdi, %rdx, CHAR_SIZE), %rax > +# else > + movl %edx, %eax > + adcq %rdi, %rax > +# endif > +# endif > + ret > +# endif > + > + > + .p2align 4,, 4 > +L(copy_8_15): > + /* Overfill to avoid branches. */ > + movq -(8 - CHAR_SIZE)(%rsi, %rdx, CHAR_SIZE), %rsi > + vmovq %VMM_128(0), (%rdi) > + movq %rsi, -(8 - CHAR_SIZE)(%rdi, %rdx, CHAR_SIZE) > + cmpl %ecx, %edx > + jbe L(ret_8_15) > + subl %ecx, %edx > +# ifdef USE_AS_WCSCPY > + leaq (%rdi, %rcx, CHAR_SIZE), %rdi > +# else > + addq %rcx, %rdi > +# endif > +# ifdef USE_AS_STPCPY > + movq %rdi, %rax > +# endif > + .p2align 4,, 8 > +# if VEC_SIZE == 32 > +L(zfill_less_half): > +# endif > +L(zfill_less_16): > + xorl %ecx, %ecx > + cmpl $(8 / CHAR_SIZE), %edx > + jb L(zfill_less_8) > + movq %rcx, (%rdi) > + movq %rcx, -(8 - CHAR_SIZE)(%rdi, %rdx, CHAR_SIZE) > +# ifndef USE_AS_STPCPY > +L(ret_8_15): > +# endif > + ret > + > + .p2align 4,, 8 > +L(less_1x_vec): > + je L(copy_1x) > + > + /* We will need `tzcnt` result for all other copy sizes. */ > + tzcnt %VRCX, %VRCX > +# if VEC_SIZE == 64 > + cmpl $(32 / CHAR_SIZE), %edx > + jae L(copy_32_63) > +# endif > + > + cmpl $(16 / CHAR_SIZE), %edx > + jae L(copy_16_31) > + > + cmpl $(8 / CHAR_SIZE), %edx > + jae L(copy_8_15) > +# ifdef USE_AS_WCSCPY > + testl %ecx, %ecx > + jz L(zfill_less_8_set_ret) > + > + movl (%rsi, %rdx, CHAR_SIZE), %esi > + vmovd %VMM_128(0), (%rdi) > + movl %esi, (%rdi, %rdx, CHAR_SIZE) > +# ifdef USE_AS_STPCPY > + cmpl %ecx, %edx > +L(ret_8_15): > + adcq $0, %rdx > + leaq (%rdi, %rdx, CHAR_SIZE), %rax > +# endif > + ret > +L(zfill_less_8_set_ret): > + xorl %ecx, %ecx > +# ifdef USE_AS_STPCPY > + movq %rdi, %rax > +# endif > +L(zfill_less_8): > + movl %ecx, (%rdi) > + movl %ecx, (%rdi, %rdx, CHAR_SIZE) > + ret > +# else > + cmpl $3, %edx > + jb L(copy_0_3) > + /* Overfill to avoid branches. */ > + movl -3(%rsi, %rdx), %esi > + vmovd %VMM_128(0), (%rdi) > + movl %esi, -3(%rdi, %rdx) > + cmpl %ecx, %edx > + jbe L(ret_4_7) > + subq %rcx, %rdx > + addq %rcx, %rdi > +# ifdef USE_AS_STPCPY > + movq %rdi, %rax > +# endif > + xorl %ecx, %ecx > + .p2align 4,, 8 > +L(zfill_less_8): > + cmpl $3, %edx > + jb L(zfill_less_3) > + movl %ecx, (%rdi) > + movl %ecx, -3(%rdi, %rdx) > +# ifdef USE_AS_STPCPY > + ret > +# endif > + > +L(ret_4_7): > +# ifdef USE_AS_STPCPY > +L(ret_8_15): > + movl %edx, %eax > + adcq %rdi, %rax > +# endif > + ret > + > + .p2align 4,, 4 > +L(zfill_less_3): > + testl %edx, %edx > + jz L(zfill_1) > + movw %cx, (%rdi) > +L(zfill_1): > + movb %cl, (%rdi, %rdx) > + ret > + > + .p2align 4,, 8 > +L(copy_0_3): > + vmovd %VMM_128(0), %r8d > + testl %edx, %edx > + jz L(copy_1) > + movw %r8w, (%rdi) > + cmpl %ecx, %edx > + ja L(zfill_from_1) > + movzbl (%rsi, %rdx), %r8d > +# ifdef USE_AS_STPCPY > + movl %edx, %eax > + adcq %rdi, %rax > + movb %r8b, (%rdi, %rdx) > + ret > +# endif > + > +L(copy_1): > +# ifdef USE_AS_STPCPY > + movl %edx, %eax > + cmpl %ecx, %edx > + adcq %rdi, %rax > +# endif > +# ifdef USE_AS_WCSCPY > + vmovd %VMM_128(0), (%rdi) > +# else > + movb %r8b, (%rdi, %rdx) > +# endif > + ret > +# endif > + > + > +# ifndef USE_AS_WCSCPY > + .p2align 4,, 8 > +L(zfill_from_1): > +# ifdef USE_AS_STPCPY > + leaq (%rdi, %rcx), %rax > +# endif > + movw $0, -1(%rdi, %rdx) > + ret > +# endif > + > + .p2align 4,, 4 > +L(zero_len): > + incq %rdx > + jne L(best_effort_strncpy) > + movq %rdi, %rax > + ret > +# endif > + > + > + .p2align 4,, 4 > + .p2align 6,, 8 > +L(page_cross): > + movq %rsi, %rax > + andq $(VEC_SIZE * -1), %rax > + VPCMPEQ (%rax), %VZERO, %k0 > + KMOV %k0, %VRCX > +# ifdef USE_AS_WCSCPY > + movl %esi, %r8d > + shrl $2, %r8d > + andl $(CHAR_PER_VEC - 1), %r8d > + shrx %VR8, %VRCX, %VRCX > +# else > + shrx %VRSI, %VRCX, %VRCX > +# endif > + > + /* Compute amount of bytes we checked. */ > + subl %esi, %eax > + andl $(VEC_SIZE - 1), %eax > +# ifdef USE_AS_WCSCPY > + shrl $2, %eax > +# endif > + > + /* If rax > rdx then we are finishing the copy at the end of the > + page. */ > + cmpq %rax, %rdx > + jb L(page_cross_small) > + > + > + /* If rcx is non-zero then continue. */ > + test %VRCX, %VRCX > + jz L(page_cross_continue) > + > + /* We found zero-CHAR so need to copy then zfill (we know we > + didn't cover all of length here). */ > + bsf %VRCX, %VRCX > +L(movsb_and_zfill): > + incl %ecx > + subq %rcx, %rdx > +# ifdef USE_AS_STPCPY > + leaq -CHAR_SIZE(%rdi, %rcx, CHAR_SIZE), %rax > +# else > + movq %rdi, %rax > +# endif > + > + REP_MOVS > +# ifdef USE_AS_WCSCPY > + movl $0, (%rdi) > +# else > + movb $0, (%rdi) > +# endif > + jmp L(zfill_from_page_cross) > + > +L(page_cross_small): > + tzcnt %VRCX, %VRCX > + cmpl %ecx, %edx > + jbe L(page_cross_copy_only) > + > + /* Do a zfill of the tail before copying. */ > + movq %rdi, %r9 > + xorl %eax, %eax > + > + movl %ecx, %r8d > + > + subl %ecx, %edx > + leaq CHAR_SIZE(%rdi, %rcx, CHAR_SIZE), %rdi > + movl %edx, %ecx > + REP_STOS > + movq %r9, %rdi > + movl %r8d, %edx > +L(page_cross_copy_only): > + leal 1(%rdx), %ecx > +# ifdef USE_AS_STPCPY > +# ifdef USE_AS_WCSCPY > + adcl $0, %edx > + leaq (%rdi, %rdx, CHAR_SIZE), %rax > +# else > + movl %edx, %eax > + adcq %rdi, %rax > +# endif > +# else > + movq %rdi, %rax > +# endif > + REP_MOVS > + ret > + > + > +L(best_effort_strncpy): > + movq %rdx, %rcx > + xorl %eax, %eax > + movq %rdi, %r8 > + /* The length is >= 2^63. We very much so expect to segfault at > + rep stos. If that doesn't happen then just strcpy to finish. > + */ > + REP_STOS > + movq %r8, %rdi > + jmp OVERFLOW_STRCPY > +END(STRNCPY) > +#endif > diff --git a/sysdeps/x86_64/multiarch/strncpy-or-cat-overflow-def.h b/sysdeps/x86_64/multiarch/strncpy-or-cat-overflow-def.h > new file mode 100644 > index 0000000000..d5ff4cbe50 > --- /dev/null > +++ b/sysdeps/x86_64/multiarch/strncpy-or-cat-overflow-def.h > @@ -0,0 +1,65 @@ > +#ifndef _STRNCPY_OR_CAT_OVERFLOW_DEF_H_ > +#define _STRNCPY_OR_CAT_OVERFLOW_DEF_H_ 1 > + > +#if defined USE_MULTIARCH && IS_IN(libc) > +# define UNDERSCORES __ > +# ifdef USE_WITH_SSE2 > +# define ISA_EXT _sse2 > +# elif defined USE_WITH_AVX > +# ifdef USE_WITH_RTM > +# define ISA_EXT _avx_rtm > +# else > +# define ISA_EXT _avx > +# endif > +# elif defined USE_WITH_AVX2 > +# ifdef USE_WITH_RTM > +# define ISA_EXT _avx2_rtm > +# else > +# define ISA_EXT _avx2 > +# endif > + > +# elif defined USE_WITH_EVEX256 > +# define ISA_EXT _evex > +# elif defined USE_WITH_EVEX512 > +# define ISA_EXT _evex512 > +# endif > +#else > +# define UNDERSCORES > +# define ISA_EXT > +#endif > + > +#ifdef USE_AS_WCSCPY > +# define STRCPY_PREFIX wc > +# define STRCAT_PREFIX wcs > +# ifdef USE_AS_STPCPY > +# define STRCPY_POSTFIX pcpy > +# else > +# define STRCPY_POSTFIX scpy > +# endif > +#else > +# define STRCPY_PREFIX st > +# define STRCAT_PREFIX str > +# ifdef USE_AS_STPCPY > +# define STRCPY_POSTFIX pcpy > +# else > +# define STRCPY_POSTFIX rcpy > +# endif > +#endif > +#define STRCAT_POSTFIX cat > + > +#define PRIMITIVE_OF_NAMER(underscores, prefix, postfix, ext) \ > + underscores##prefix##postfix##ext > + > +#define OF_NAMER(...) PRIMITIVE_OF_NAMER (__VA_ARGS__) > + > +#ifndef OVERFLOW_STRCPY > +# define OVERFLOW_STRCPY \ > + OF_NAMER (UNDERSCORES, STRCPY_PREFIX, STRCPY_POSTFIX, ISA_EXT) > +#endif > + > +#ifndef OVERFLOW_STRCAT > +# define OVERFLOW_STRCAT \ > + OF_NAMER (UNDERSCORES, STRCAT_PREFIX, STRCAT_POSTFIX, ISA_EXT) > +#endif > + > +#endif > -- > 2.34.1 > --000000000000fe52e705ec8d1e3a Content-Type: application/gzip; name="strcpy-evex-results.tar.gz" Content-Disposition: attachment; filename="strcpy-evex-results.tar.gz" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_la0u1bls0 H4sIAAAAAAAAA+z9W7JlO44lhsZ3tmI1wLXF90MNUAPUgbKwVFhVmaUi0zKiVFm9v5PA4FwkMeby dexaVl3pln/4Pn7cQXKCLxADGPjb3//lH//lv/0vf/m///JvP3//t7//6d/jl7t+lZLGT1+zW386 F3Iu3v3JpxhdydHl8Cfnx//808v9u4zm+PVf/vb3P//r6/Wnv/7zn//Tp3/3u7//f+ivf/g//vK3 //JPf//b63//53/9315/k9XwD3/+p//8H//qf8mP8Pr1T3/56+v16//687/9h3/8T5eufv31L//1 df369c//9H/Kz+vP/+v4739wL/mz/sDPXz5U/Dn+tDR+pp9resffX3+O1/845fwhl39CyPLT9fHT /7hQmJw75Vpu18/6U3KV/mrJVC6kVS6knxbL9TP/JFeHXK+VyXnTX0naX+mf+gtGrnmRq85DLlG5 tsm1n16C/IytqV5KY3LR9FenXhL6o3LJjrOo3Ji3ISd/ZeTyKVfku8pP99pf81Su7HLlxznVS6vo b3yvkQuvs78gGr6mUfRz6aUyfQZZhW85H3/c9YHXd/94nb8eWH/R9NdclP5S0v6uo4zJHfNefryr +p3R6zg96y/Z/qrqpci8P62XbOViFLlc/Yf5yz7seqm6H66fMSbdf53IFdtf7ugvoD82znKsszHf QfTSfBW9+Mz2UTX95aJypeJ8iex8aUauB+y/OvetJ3Ldfl/CeBvOl7Tq07+Wn/v6lHMiX/OPeY+B yJH+Wsf5Ms+JdR7C7M+egyVCbu6jTOTIPpIdkvB9Yx+tcnH2R85B1Uu59RmJHNlH47/HPopd95Ff 5dL9fW6Ta9c5FmUcP7Un6S8mKpdOOT0Z/XUwBZELmcqd527NWeXidSGZ8/OWO/bRJReDypVURE62 qJUrp5zMtx8HvBe5HpicvVcw72kskyHXqD7Dqc8aoU+Xqvbnqdypz/v7XG/aX6Vyuz69+8mXisdP d33YWGeJ9hd3ffbrXtaWfloP9nx5y5WzP/muIef1+xqVS87KaX9B10sLdB5SOsfZosol7a853l8z 35ewzq4Ld8jVzuSy0Uuf6zPLfmhy5Fm5csi1UlQuOVlnrdD9YO/prvZEb9OeoN9XDn1ehuB10Q69 jo7Gfo+FyqVTLsQg93XLWe8jus5KM3LXWTXkSim6zqheajBypYtcSCpXaX+1nHJJ1nX8ifP8pOdE M3oJLsh6yV368/z7mtGLH+fRkBvr7JLj52AzepF1csn1EEXO0/3XD71cF27wsl5a0vnb7Lq3nLGz YurS7zhwh53l2PeF4x4rYp7JOktznbH1Eo774eovpaTf2dSep3oJx/0wxtlUzo3xXnKZnZ/huB+G XNZ1VnPR9wPTZzjtrGucocg86Iml30vkrD5rh5yuz8bOpRCMXuZ5lkX+skPoPASjl1x0nXmfdX2y eQ/nOR/1XBl60XvzQS/R6CWMe33sd7Uje6Hfd57zV39N91/We6x3qs/D/hz2uNpZrUz7mu3bcN4P 1zzIfo1i8I7+6P0XktFncjrvPb4+zEOy+iwd+9breUb1ko0+x4ND7r+kcp6d8+Z9NB4cUX7GGlWO 6uU85y+DPIx56Jf9gnuMjvM858ul+HGO6QN36NNzuXbKtarjHAblkEt03s9z/upP5q/9+KJy1B4M 5zl/fZ/sh+sBgXHy+Wuvc50F9RdUB7uc79vzfrjGmfF9Xvuj91g474fyk6PKFeyjSOfvvB/qdZF0 1YvrH/R53g/luqd13nFet0j1ed4P5XoAZJEL+n0tM7l4nvNDLsg4YSd3eh/F85wv8mCX9dm79sfu h3ie81d/TvXZcZ7R9RnPc/7qL3SVa6pPx+Yhnuf8tc6c7oeUdf5e9PuOd0C91Kj+s65f8BMCO3fj eT80cUxJf2qHuAe5Q5/Xg9/rvI//JfYns1vjeT9ccrmqXOwf5M774ZIb58o1zpx1HhLbf/G8H66H UcvoT9cZvW/jec5f/QVdZ9nFD/2d5/wl13UfRfVP9Ey/7zznrwnMOAexzui+jec5f+1Xn3Qe9b3S C7Nf4nnOF13PwV12Wn7et/F4B1QxW8c70MPP0Oh5Fs/74Tpfxhdf/Tm1zx72u70fetH14jBO+k6N 9n7oTb9v3kd8/s77of44secvffbyYf+d98OQ0/XZu35fp99Hzvmi+2g0+fgei8c5H/y1/7S/FPX9 UOj3Hef8pQ85ca6fSfUy1ETkjnN+6PF6qMrPKO8O5+i8H+f89e+DvBuucTrxK3qqT+v/zAnnGfyf PbB9m473w7U+x7+71qfMt/ihmV7Sca8MvYx3UXj7J+j3peNeGXI+4PxU+5rag8mRedB1Jnbk0zsg nfdKF6BjyFXYkdS/lLyZhzb3UdH56+z+S8HoxY33dBgHEt5HdJzn/dDFoSXrDHYyXdfpvB/69Q/1 no5R9RLZeZbO++GSy7o+i0N/7NxN5/3Qr4Mowg6JH/o73g9VzBY9Bz3OQarP8165xil2wfV9WC/0 3Z/Oe6XDrrvGC/uMr5fjXglBgASZj6D7r9D1ctwr1/mi57W/3gMEH3vLFSM33nHjZ/60j477Yfz7 62Gj54vOA70fUjHn4HA1jp8x6nnW6fcd98Mtd/UX8of+qtXLeO8PObyr+H6oZv91r/uvN/0+eh+l 4/0wzrMo66wH2NeOrutm9JlDXvbTg18qnfeKAy4aBLB4fAcke6+E7qXfVCBH9WnvlWFCjZ85+w/z Z++VOPQ55r3iXGJy2Z7z4u8Z/en90Kk9ke05L36Xcb7oPPB3fz7P+QEUan81Y78zfZ54XLguwLHv xH6R+QuV6TPbd0DW9RLStM+oXqxdl/U8C7FDjumlmPs2Fr1v9YU35Ng6O/G/Dvz8Oj/V/30dN+zc Lcd+aLr+xZ9ck8WZp1wNRk41PNY35Fh/tZxycuwNuTEBj+/G5mx/UeWqrs9G/Sgtmf56Qn96zrfC 5qFZvSi+fNkVsJMr00s3evGzv4nb03dqP/RyXZeCL3esMy/m71su49+RuISi/t3UgG9u9+aUs7h2 knUycfFhjqz3Spn9Jdsf8HD58tHfi8hZXDsH9Ic4j77hVW//uOkvK86cXSD93fvGfl+DvRvgt9Fz Qs3lD3EzUfDlrLit3CuZyR3xLzELgP4r+p+qdo8PVO6wz8a8F/mpfq1xnjUmZ/Ej4MV94pSZyVl8 Wp7BA6ee64zqxfgxR4BIlZ/T/tR1dsiReA3BH4a7CP4XPQcPufO9UtSeHt8Xpj+5EzlzznvZCGLX F7ULFPc95M7zs0n4isaHYN4L08sZB1HU3hzjnPEamcmxOAjEo9xxOqtenuMg7vmLiF9Se/eUs+tF LPyq72Hpb5ULz3Iv1Uvr+D61dyF3nxN2P4zAql/xeq+I3+cy8+Iid68rG5eguN9lbwEP3/bfWy6d corDhmudyjlfXadyZ1xC6cDfc0Z8QWByNi7BA0f3ijNX36iciUuQ+J7RX/RWn7eciS8oHjgz8Oma 6ffZ+II0+2sad5GpPm18QRn66Ihfu+3dU87GFwTpL/54xBfweT/ejV3cPC/FHVWfKTE5El+gI/iZ 8T2dfp+NL+he+4sN/VUqZ/TigDeKf/G2Q045E1+g/pMh1zROwNF1ZuILup/rGv5WT9fLc3zBjFsr VC82vkDHqYE9A59OdJ2R+AJ591/zh3d/ofPO4gs0TqA7xMlRORtfELHOcswf+rPxBVH+fbzGC/+S Z3IkviBo/IvicjO+wMgdeonXgabrpVTso0LlbHwB5r1l9TN42p+NL0gS3zH8DPLOiVyfNr4geeD9 EXgcGyeJL6h6r3Q/7zE2ThJfkAUHv/pL+k5NbD+w+IIeVc7rOzWydU3jC6r2q++O3X552w82vqAA f4ed3Og4bXyBjnzIqd87s3VG4gsUf7jWTdJ5KFzO6CV3xaezrhfX2Lyz+IKq/aUs61rih62cjS+I Rfd7C+on4vNO4guK/gxJ/Vl0XbP4Aj3PWpt2CF2fNr4gJY17ilX9S46uFxtfEDvie5r6dyPVy3k/ BI23GHLAmTtdLyy+QM+XXvqHcdr4gir21cAPoU/an40vqEn95aLpG/c1cgY/ah74Q9d5p3YWiy/w Gg89Dopf6v4mciS+ICsuE9TP0D2XM3hcRdxFnXgju6c/xBfc8d50HizulPF9Ve/3Hug4WXyB4trV +yXOysgZfPPGw0P5sP9sfEHE/NWgdkil69rGF4QOHAF+osTkWHyBjPx6YOUVtzdyRi+hq3/eV+Cb Lypn1pnv0IvGJQBvPOVsfIGXOIGq8XwDb2TzR+IL1L4e8TbqX+psHp7iC+qPhPG94wSMnIkvKF3x Ktf1nI/snCfxBRrP19R/PdYn1YuNLyjAV2oCDkv7Y/EFB25P9WLjC9QD1GecY2tUjsQXVOC39fV8 35L4guh0nDNvKVG92PiCWBDngThHvh9IfEF4YZzR+kPechYPB45XCnBtuo+sH1rsskud088QuZzR pwOeE2deCLtvTXxBxfuoy8X+xu2NnNGnKxn4tvaX6Dqz8QUe8VIOfvZOv8/eDzMepdf4fA6S+IKM +JdYcC5Rvdj4goS4oND1/VDZOc/iC+Rev+YduHZg9zuJL/DAmcPEgag+LQ7kq+qlOLWXqJ1s4wSi +m004P7qr9DvY3ECiJuZ+6ix+WNxAkXPsxqBx7F5OOMExrmCeJSKuHR6TpA4gZb0nKhO54Ha5SRO oCfoU+fP0/k74wQGzoh13RE3Q++VM05A8N4E3BG4Pe/P6KVlxB06tXfpu5HECYzESMHxOt4rLypn 4gQ67neNI7yGTeePxAlkXWdd10uhfjASJxA89m31z3Y5ixPwuP/aGidg5EycgNidEreh8UTUj0Li BCSvbsxf0ncAfR+ROIFxMIg87KxG+7NxAsEjDgk4Oj3PaJxAVjy2r3HbRs7gt8FhXRe1X/j6POME NDFxw/vp+rRxAg34tPhp7zjxU87GCUTgjU39IYXa1yxOAHGxIvd4fto4AXlPDf2ktMT3GDlzP8Tm 0e+Hdw6JExD7Y+xbxBd0ep7Z+0HiyEYcC+LdqJ+WxQl09Id4G41LMHJm//XeEF/Xl7gZI2fjJ6r+ rHgfUf81ixOoem86sQuvZqictefLvP9y0PuPfp+xz1KGXAnq16d+YRYngPVZdL8XOn82TiBljRNI 6qd/uI/OOIEubpuX5H025FOy77NxAnXiKyPAX+xPNn8kTkD98wO3CM94x2OcgNd1M/pj+8jGCWg+ ukecz52Pd8qZOIHggMuIX3jMHzs/bZxAcPP71J7neBWJE0jAi2e8ovpDFMD7xOsw85nrxP8SkTvx 4ihhVi/J01ccFnEskPOzv3L216dfWNufuGhY+pFx7udEVVxE7nfk7ao/y8ilQ67qzDhJ8B9yiqMb uXb2p/5IFZD14pnccU5USd9TOYwzdCpXTjm1vJwkpP+6865PuWD0km451Wek+gynXtq0yydvReL9 nXEJueu7MYOfAf7IU87gf9lNvBHv1EDnz+B/mm/tR6KF4lyJ9nfYdV3cDCqHOJ1M58/gf3nizBFx QWpPGLlTL7gRR5ycjjPScRr8L5WZX4x3Y6T9Gfwvzzz2gPet4pSnHMH/sP9mfEih83C++4MQlUj8 kuQBXmql+jzf/UEW1vjp4C/PdJ2d7/6BpxU9PzUvEvHep9z57h/29cS5+ie5YuQm3u/VLufr+nz3 X+MUP62/4xkc7e/0707c75LTOH/v6Ll0+neHPoPKJfUXeLpeTv9ukA6ETwA4bKfn0unfDRrnNvCj CH8yk7PxRAk/cdLN98MpZ3BD+Z6xPvPEDWl/pz85SGCjrLOs60xxCyNn5kFxtakfjWshcmYeXFL8 NiEfqLL9YHDDADw83PG7jc2fwQ3H93nI5cXePeVOf0GQwPnxcwRavf0oRs7oRfG/sf90H1W2bw1u eMkFXS/DUHvWy+kvCGLw6v7FO5XOw+kvGPn5wDcb/CF0nBY3TLrO2oyPLFSfp7/g0mNDvnZbcUoj Z/XZNb84AG/0dF1b3DBFXS8Sv/TY3+lPHvOnevHAbwPdf5a3Sc+lPHE85J2dcuf9EMXwFzmNX2p8 Hs77IYohMuQccNFA18t5PyDv3SdZYM9y5/0QFd/yST7s181LZeSIXprKgWch0H37iBu2NO1ruv/O eyVqvqd8n76nPbuPDG444kqgl4g8Wj5Oo0/NY8iSAPFL3UxE7rxXosarDVyuvtR+ofq0cSVZ8o6U SOvXnad4yBncMIohKXIYJ7UnDG4Ysf/ynQ+b2TwY3HDIqV6KxrciTvyUI/Eh6K8grutBzupFzrM8 4zxaYfNHcEPJX9HPG/s9ZDZ/BjdM+r6RfH3VJ71XDG6YlHdJ4gXUnq90/s77ISleOPBm5DvJXxi5 835IOJcG/ts/yZm4LvXLj0Bj7c+x9Wlww6Rx26M/xCVQe9DghkkC8UTu9dL9R9fnec4n8OgMnBr9 sfPa4IYjTk7jCxDP3ug5b3DDpHmYEh+i7yPen/VLyYna9L78pW4tJkfi5JJ8X8O6pu9NgxvO+Loy +aVa4uM0+tQ43CIPMZGj4yT8RGIfl8kHwd+bBjdMQgSw7iP6HjO4YYJ9XSaOwN+bJ244+Auyys28 iU7Ps/OcL+o3G/1p/AS3B0/ccPSTVK4AV5O/sHKWZ6GqPhP4peh9RHBDwfv7j3pwneLURM7gsMXp eRa92j2efd+JG4o+df7ifD9wOaJPnGf10/fZuJLip14QX8fO6xM3HPdX0P1eEPfb2bo2uGEWB5bE e+Dd4dh9ZPKLM+ylMSEfziWDG173l8ShVLWXhxzVy3nODzmN0xkO6F+azsnkrF6Kxrt5nNfUHrS4 4QgLUn8W/GDUnjC4YZaHqfb3wY40uGHG/hlAkr5XqL/gxA1HP0Xjs4LGWSFO7pQ774eKdT0c+2on U7vnxA1H3IX4ed68KhpndcqR+JCu+Lvz4A+h47TxIR7rpcIup++xEzcU/SNOTt8dwMdOOcI/0aec fl+h8275J0JSvTT1TzyM0+KGMvIu7qIP68zGlRTwTxSH+DO6j+z9UBHX1Upf4qWMnDnPilPeppQ+ 2Gcnbij3wut18zPccXJGzsbJNR2nB45H98OJG4peNN4N/s9Oz0+DGw7+LMTbAKekfqITN5R7DHFr eI9Rf53h+23qD5Z4t/58b1rcMAqfcRc36IJznXIkv7hgneG9mdl6sbhhkPjkIQd/CPXX2fy4UDQP WvGAp/1g84vDxCkn3yj9Posbat60V4Pg152/csoZ3PCWy+ovqJX1Z3HD1IADlcnfyr7P4oZB8RE3 +cFqZfokuGFFnrDswzuv9ZAjuGHB9xXNf+Dfd+KGVZ5vyuOi8962cc68ZBanOv590XyQN//nIWdw 9JEfMPZ7B2+smPdvuZmXbPxSRYiM5bxOuN9XuXe+ocmPw016bYy84LBGzuTHSbyN+PlUznO5M2+w lhvnwrpuTI7kDb7QH/L/PJc78wbL5KdNek/XTPVieYkDxjnz6jY/w1vO5g1OfDqFT/3ZvEHx96gj S/zCicnZvMGEfK5huIhe6DgJL3FZ8lecpDUQOZI3CH7hon6p2uk4T7sO/D0jf0Xvlbr5s95yJ27Y G9ZZAI8EX2eEl7hDTvMUm6fjtHmDc12HgnzDzuQIbphl/p2f/nJP5UjeoPLaqiV1fSaXM+9+8SOL n0LPl82+fsvZ/Lis/k8H3DBQvZB3fwC/adR7OtNxknc/8sci+HQK1ad990fgHRrnI7Q8TM76Q5D/ V/Kab2jkjF40ry6II0T4jF9MjuQNNsVTu+Z9hk6/j/ASy/thEN/Dr8j2H8kblJVXEV9y3u9vOZI3 GHTeHXkHvOWsX1jsyKT30p1nY+SsX3jyX8+8QbZeSN5gdpp3hvc74t2MnM2Py8qHW/AublSfhJcY 67PM9x+bP5I3OPPmJf/dy3OQydl8SuRhesQrJrY+ad6g/mzw0xban80bVH7MkbeLc4Lq0+B/Pmqe jfi7jb30ljP6nHzUacYL03lnvMSaF+nSyrNu5B70GQUw/HXXCznlSN6gvDuCBH4aPPwtZ963mt9d JSBPvo/2R3iJE/ItdP52O/ItZ/MGET+fU7HvuLeczRuEPwt8SOAJPuVs3mBBfmPAfqD3JuMlbqqX kpEPRM8Xgv8VPc/mu6rQeSB8lXMesM4SXWckbxB+G+T19EjngfASIx/PAX/PVC8kbzAor0qa8VJ0 nPbdH5E/FurKG3rIkbzBGPTd7/W8bnR9srxB8A/69rE/s840v7HeOLOjcta/m8Bj3bFePJez75wO Px94cRybB/IeE39BRZ2np3OC5A0Kr/7w2xT4r9l6YbzETvMmEBfUOpezeYMOeRPMf33LkbxB8FFH xAnQdwfLG5R7oQsBlvGD3XIsb1D9RDMvJNPvI7zE00+EegX0/UfyBlMq6C9Yf+stx3iJdb00xZ34 /c54icF7Bz90i1TO+Au88rEMf4jopdBz3uB/5Y7X97lZnOstZ/ZtB498n3l87NxlvMRJv89rHNLD 9xG/sJ/8wv1Df4SXGOsMcSyt03VGznmv/pA48X663xkvsc5/0voB/kHO5D9IHG648wN6pfuP5A0W nb+Adc33O8kbbDp/ucKOZHoh/MLqD3Ezj73Qe5PlDWKcceaTsHXG8gYz8v8QB1j5OG0eptP9V8on OcIvnHD+gt+U+idY3iD8yYrrTD65U47kDTrNy5I4x2FPUL2wvEHNz2mT75fL2bzBjvu9rHy/pxzh F/bKT9vwzqHnLssbzGqHBLz7I9Unwf8Qr5+VF7xs/ta3nNUn8iID1nWk88DyBpEH9nrpO45+H8kb zHpOtJk3SPuzeYPiB7t+3vNH+zvzBtXwV37i+PzOIXmDbvKpgn8ps/OF5A1KPSnJG6yf+jN5g1Kf YsxHWvMUTznLL+xawnrTfUvvTcYv7MBLrHlgjs+Dxf888jSa8nkU+r4leYMpgj+56zlR6PnC8ga9 rJsYwI/C+7N5g1HnPeN+4OcE4RfO+jN77Y/adSRvMDRdnzPul/pfWN4g7nfsW+S1GjmjF8mzGPpB fRnq32V5g07z0Svy0an/muQNal7/vW9DZfokeYNp4jmK+5ZG+zP2WchTLrxUjvVn8T8/+d2Qb1jo OFneYJGfyHd78GvYvEEHxlrlr3jyzzN+Yfk/XvN97zy+U66ccrVNXAY8kIWtT5I3qCvBS8D9Y3+M X/g1+6vP+ArhF57fl6b/k+mF4H960wzcqT7jJCRvcOKGM45F36laWPRjfeYg66bMvDP1tx5ypC6p nDhJ0s5kP/S1v4B/R3hmfVW/fu3gISiL3KyDSvDppO/iPOsX670CuYlTWtywTXwF+dPINzRyJz6m vLRjvagfDHVJjdyJG2r96VH/T98PwA1POYMb9nbLpcW/ZOSKkcN+qH3dD6ecwQ17A94I/iysTyNn 9DLrYfaJG9J5sLih8Ep15dOUe7oyudOOdKj7EKcfsz7IlVMudPWXO6zrRr/P4obRab5F13sTfKNG zuCGUf/PxA3xLjZyVi/AtWPH+51+3+kvcFpvdcjpemnqJzJyu1464gSET1XXZ6Xr5ThfVr7Rmf9A 9cLihVWfQXlH/IOcxce6/pz3kS9UzuKGXvk/W1jt+VPO4oaanxN/Zt14jYMwcsX0B/98Bu9PovuB xAuj3mCZfOK0P4IbRu1P/YtSho7JWb0UldP6Ldc1QfeDzQsJrWO/63uFn58ENyxazxR55cizOeQI bpj1nG94VyFv0MhZHsgM/E/lOp0HghsqT+zAt1FPka0zxjcK3HD69Qvbt4xv1KNOL+qW0f3A6plC DvdRp+cgyRvU/Nt45zt5Og+EbxQ8yL0pj0ti805ww5w8xrna16ecxQ31pBo8p3g30u8juGGadYhX XqNTzuYNyjpZcMNC593ihgU4bIJ/gu4jghvmoHEs2a11foyc1adHf/DrO6pPixuqPwv1esc80H1k /ckTHwNu3+n9QHDDhvqGLiPfkM4Dq1enfjfhk7/joY2c8QvrSdx+UDeiaxzEKUf4RhFn3MHbG+k4 Cd9oAg7kEF9A963FDcd/Ck8DcMPK5aw/We6/KgH30h9dZ+f9kDXeaeCGs845PQdJPokDLgrcItJ1 ZnHDlBRfaYhD4uuFxAtPfMWteWCHHOMbvflp13hoI2dxw4r45OoXnMvIWdww6vf5vuJcpxzBDRFH 7drKo2vk7P6D/zpvPKWnnPUzID/VTXspsnk3uGFF3ufAKeFX5HIGH0vgP5t1GDtbn6yeKer/VeS/ 0/3HcEPwot68VFzO4oZR10tu/YMcq2eq81dgF9D9x3BD5GkUxEFQO8TghgX15psk1P26+T9POZsX onwc7a6zzNcZ4xtVv35Xex48l6ec9UupvCZSvvEcI2fzSfLkA8zP9wPjG0UdxgC+mcbHadaZ8t11 xf2HHDt3GW44+T/V34M6hUaO4IYYJ3hjeH/2nG9u8haifhU9z6xfWPiWJ649/CFczuKG0Ged+XFU nww3BJ6awOtH9UJww6Drs6H+Q2XrheCGkzctK19QaWxdM9zQ6/4Tnue7boSRM/oMUb+vwd6tbN8S 3DCg/rTiVrOu0Cln80kmbyj8ydyuM3mDXQLqRB48nnTfUr5Rxf8C7Dq6/xhuCFw7Tb8wO5dYXdII PmPU4fD0+whuOPcDcFjeH8ENm/Lo5lk3kN3TjG80Yp3lsvjZjZzVZ3hBLzrvgX6fxQ21Xnmf9fg6 tV8Mbui1fqPo9fVhHxG+0XGuBAV8ZR7YucTqkpYOfEbngfpDGN+oQ3wB8mgTXZ8EN3RYn+CXSnSc FjeM4EH2Hny/9JywuGEMik8H7L9M18t5zmNdC76G+aN6sbihvDfHOtP8uELvFYMbOo0PGTgX+Eb5 OUFww6D1PhPeD5nLmfNM7MGgjs/n9Un4RgviC+Bn4PuI1CXFOiuI26b3O8ENJQ92jPP1eh4nwQ3H kSP9tTX+2sgZvci7I2hA3q+bD+mUs3lSDeeS7Hev9eCtnLXnC3Bm8GMW/n3WPqs3bqj2GbVDLG6I G1EFhlxn82dxGeHHG7hADh/mgdQlxU0z6+ZW+g6wuOEb75h4FVvXFjdsk8cT9UWBUx5yFjes4h8a cg34JtMn4RsNE18JqDvHvo/ghunGc17P+ArBDYVnbfB8Ib+RvgNO3FDNEMkncjP/dl2fH/BiufHb vD9/vOpTO1p4Sg3P5cyL7IpTVr2njVwyctMeBA700F875Prk8QSfeFW88ZQz/J998mrinQpeWyNX TH/Yt4hTfZA75i8Lneabl+VeZ0bu1GecfOlJz8+i/gIjt+uzaV6b5FXCnlC/sJE789x8QH/BI66S ypn8v3DjqcDf1X4xcideFT3yFGedZU/1aXhDp2dM802d4l5ELp39VeTVOeQlVy536kX+c8jBvwQc 9pQ77LMm4bfoT88JT/uz/G5x5KV2gWfG/KVI98MDjteUr/55H1leuMlrq7z+YuYxuWTkgL9rHueP d1QvlhcuoM4d3jmer0/LC6d5BV7x4oGPUX1aXriI+yEL3vzjMx2n5XcbLlGND9Hvy3ScljdU6lUP OdTh4OvF8obqznJaZ9KLW5LIWd7QCh7Iing3jZ8wcsXIoT6eAy6jeM4hx3C8iHMU51lheiH8n61o PmULqOfG+zP6rE7louKbyJswckaftYA3FHlZdP4I/6facwPvVzxH40OMnNGnRx0/5AkD5zrlSN3A qOusYJ1F2p/l/+ywXxr8Np3dK4T/s+P7Zn1YR/Vp+T+nXrryNXfen+X/1Pe7/+nIe+n0+w47pCi/ 74oXV9qf5f8U+0P08nreD4T/U+JCxjjzWv/ByNl11jR/us96NrQ/ywvnJG8iScE58SfT/kg976L8 WQ51JjPt7zzn85vfTe1r8D0ZuXTKaRxLuetURHaeGRwvgydx5Eshz5TO+3nOZ33fDp69ur5vjZzV Swc/X0D+Hzs/Txwva9zYiJO77026bxkvnPYXwftTeH9Gn74oT9usIxaoXmycR6vgBwPPOj/Pzvth 8B0q71YF7kTvTYPjJXkwaL009Me+z+B4SYBCzZcCjydbLwbHS1IAQnm3wMfJ9GJwvKR475CrKx/n KXee82P/aX8R9RQ9W2cGx8ti6AiOCz8RtXtOHG/kM9fXu56DF3oVJmfzdsUuHwch4q/Zfjc4Hvad 5NGCV5OdnwbHG/UwVS8d8T2ezvt5P4y8VvWz3/xLdB7O++GSy8Dfgf/Rd6PB8YrmNY51DTmuF8vv 5lBf9OaPpPNgcTwPPMBPnq8XkzvP+aL5ZgOnRN51YfvP4HhZHFjKC7fihqeceQeoRVrFzfthP9g4 Dwe8P2p8ZKP2oMHxMngnBo6+8swaOXM/iB0x+sP30XejwfEKeO+a8sDcuL2Rs/sW+dMBeabUzjI4 3qVI13EOwo9Jv+8855u+24X/zD/bWYb/c9SzRB3GmQ9E5c5zXomwlMcM/dF1fZ7zDfd0E+D27fc+ 5JL+61tuxIfreZbBN9MC08uJ/xV9fw0/E+r0FmpfG97QhnrQ7eYNpd9neEMb6kFjXd/xWUbO4sxH fjF9dxD8LyG+IKo97+i5a/C/qjxrI75A9YJ4jVPO5oc75F031C/OtD8b59GQx15QpzBTfZ73w9Jf /2CfGfyvav1ar4Wlft15g0bO6KUDD5eT585vPOXs+0Hu25mv4aT8LpOz8Qyo91knLyqd9/Newb0w 4gS0P8SjGDmbh1n1Z0FdYN7fif85jfMQHPelcrS/817pl/51nKmucQKn3Hk/dEmskfFCL/TcNbyh HXzbC+5Lx3neDx11VPq9b6mdbHhDG+LnR5wH+E3pOAn+F1QvZfIs0HGaOEAvcfNdzBhZZ9QfaXhD u+JiA98Evyn1Rxre0K78tJK3jbomfJxGnwnz3kv90N95r1z9IR+2I+6p0f7Oe6VrXJbU0UQeHzvP DG/oJVeBo6NeCH2HG97QBl7iLsTJj+9Ngv9F5O16xLEUdn4a/M9rXojsQ13X9Fw68b+xXjQfL4eG 9cLsuhP/G3L9kGPnhMX/itTD7PJ8l3uanhMkL0vw6Y76QE/vB4v/+emXmv7BwOaP8IYG4JsduCF9 3xLeUKmPNupswT9P/RMW/4NH20+evUrtF8Ibqje3O/K5TjkbJ+DwfeBbq3QeTvxPy5Ur/gS7ILB7 zPKGCn/4wD0K4gA3/9LM47PxpuJ3Hu9UzY+85mXVZ8S/s/l4vs35U//gjj+85dIpF28cT3GZ7d58 y535eO7GG8HDuu33W87k43mJf5f+IEe/z+Tj+RKO/uj3mXw8IFFu1lGpmfZ32Gf9RxGCpvl7b/4J I2fyzjRvftTZQp27wuQsj+ftTw5YL1zO5ON5r7hMQbxwoXKEx7NqvaX5bgxc7tRLx00z7/fmPZWz eonKrxjU/mye9md5PDWfMmj8ktM6pUTO4E5Fcbyk/lOtw2nlCI6neLGYq7/ufDwjZ3CEinpn4B0B j4uRS6dcRh0qh7wzvt8tjpcr6rkBrwpULxbHKxMfa9pfpd9ncbyMuIus72m/vYtvOYvjpYL1qXiO z7Q/W6dJ4lOlP5UrVJ8Wx9N40xFXFD98H8nHiwk/df7kL6ycxTcd8BzIRTZOxuOpeZ9txqNU1h/J xwtJ81NnnHFk65rk48WoOJ6LqN/I5cw68xNnBv7XE5Oz+XiCows+/frQ31M+3qjLpt/X2fyRfLw+ 43Rmf2x9Mhyvg/e16jnv6TzYfDwXUI+vIw6Xfp/Nx/Me+aLApwP9PoLjzXMCdnJj5y7JxwuKFze8 3yu9H0g+nvIDe+UV8xK+z+TMOnOp4zzT76t0HiyO1+P8Pp33SveRxfF05SUhbv6lZgWTM/7IInkv I78A9erovFscr2XFnRLeVYWduwTHaxl1d1Cfi55nBMfTPIaRL4X3Jt1/FsfTPO0y8zv2d+pbzuhF /RNFz7XT/3nLkXw8xfHa+H8mvuctZ/UZVS8e7+LN//mWM/oMGGcKBH94yxl9hpkX2Zq1y285y/Os PNajXg/87HS/n/dDvs4zxTsS6nPR/WBwvAyehas/1GduzC4wOB74pN/1cxrdtwbHy/Db1LteMp0H g+Nl5ScdfnrkRXYuZ/HNirp6k+eSjtPG73p9H8FTIjQNTM7gK1LPa/jbN95QI5dOuYJ80Tbz1bic wasG8Cr4GPytie13guM14Kl4B3S6PgmO1zL4fuOa73vKWRyvIT9n4h2RzsN5zo9xAjd8vT71R/Jh kfeZ1voyp5zF8SaP7sSP6DlPeDyl7oPgELqPOpWz8d5ygnfwPt11Doyc0eeNk9T8YV3bfO0EP3sA r59j5zXh8UxY11HlWqfzYHG8HIHLqP8FecJGzugzwD8fZh4tHSfB8bAffAXvJDs/CY43cZmeVv4C I2dwkhZ0XWud5llP+JSzOJ7UdxU8b62PYOQMjif1rgRvhJ+d9cd4PJuss0ELp/4JLmdwp1ZULwlx T/T9R/A49TM08MI/fJ/B45rmuQ05+OepvUTwuBxR38kD72D3mMHjRh66+r2zh13H1gvB4xL00nDO 0/vW4HFNAsQFd0Jd4MbOCYLHSTzQO7+4U7vA4HFzXWphm193foeRs3pBHnQLBC++5Y53wFhn9bX6 r2um/Z33w/v7Ku4/+u4geNzMYwd/Xad+FJOP5/R9M3ljzzjHW87icR64fc4aNxroPFgeT4e8wQJ+ TPqOM/l4wI0EHwM/LdWLxeMUhx2OKfCq0Hk48/GcxrELrqb7lt63Jh/PoY7fG8ej/gLC4xm74ngV 3xfpvrV+duAWqc34ZDp/JB8v6rw35Ms0ep7ZfLwIfc53Kj3nGY9nBW9owLlE54Hk4wFX66g3z9cZ ycfzuh+0nsPDec14PMGj22p/Pq8Zj2f1kMM6Y/NA8Li85vfffKqnnMXjpA7qyG+N7VkvJB8vq52l iNvT/Wfz8fRl0IUWSdcZG+eJx928mm7ytLUt/uWWO87PNvNevMZXjngG9n0Wj4tSd9ojD/cJX2F1 /JKOsyPPJlM5i8d15APBPqv0nLB4XJh5KJNfsbDzzOJx8c7LKiSv55YzetH6eP7mzd5xvCln8Tit N9iU31neD+z7bD6e9/Bfe+XFEXfILZfw72xeXe34PuRvPsklIwdcraB+42YPvuXOvLqWgW/WADw1 MjmTV9ey3/vb3qlvuTOvDvmiAxBFf57Jmfy4du+jmj70Z3A1jVtryscofkWqT5Mfl+b+Q92Itr1T bzmDq+HE8cpfeNdfMXJnftwtFxSn3N+bt5zJj8szzzTBr8HHaXC1PPOkIvwoierF5MelFmd/+v7j 69PgarlOOcSzb3bBW874ocvw03WhIRjzFwvVC8HV1D/Ycb/veUtvOePXhyU089xcpvN32lkBdQO8 JFybvJe3nPFDCw+S8ARDjs7f+Z4OasdLnUnFnbb4yLeczQND3gvem97T7zvf00ECUJQHGXhOoHJW L071Ejt4J+n3EVxN/NDTjhHaeyJn8+M8eErl3XL6od9yNp8rK44QfLXvgCnH8uNer72eFOuP5Mfp 9wWtm3TG873ljD71HXDzzO7vzbec0afmHwXlWz/fjbeczY/DjTj5r5/krD6R/5dQn6Sy9UlwNV1f ftap2HG8t5zRi74bB09mtXFkbzmjl4R5zx31415MzubHTb7YijjcQsdpcbUEucmfHOg4D7vnnYd5 47e8P5sfF+d8TJ5Luq5tfpzGiY+8SNjzVC8WV1MenQB8+3gf3XKW51LjYdN1MYEXjp0vBleLUkBY cI9M/IO3nI2fkLjKkR8C/ws9Pw2uFjVuXuR0P/D5s/ETwsMy8p6mv5zq08ZP1KZ1NBt4/QKddxs/ IfyPkmel+yFQvVhcbfL2Tj90pfNg4y40bzerP8XNOn5GzugzFcxf7BbnesvZeBSveE5oH+wQg6tF IWgQHBA8bZmO08Zd5KzfJ19w8+wdcgZXG7y2SeSqR7wU06fB1VDPcsghPiuz9WlwtYi63Fn9KGfe 4C1H6qAWjNOtda+MnMHVlPesSCCtrDN2vhBcTX6O7uTLJf2ayZl8w9o0X7QBl6l0Hs77Iem7QeoO Zot3vOVMvmER/0v5ScjnonaBwdWS8hKN/jzy4+g4z/sh6XtK8HDUN2T2mcHVhpzm34Z5ntFxnud8 0ji+gYfDnuDjPM/5hHqmRRJXHvefwdUS6sIOfFrnz7P9bnC1BD6IojzWJ45+yxm/jZc4HU3v0P7Y fWRwtaR1/yR/Gn4buj4t331EHnTRfJmHfWv57n3X76vKz9ASnT/Ld++Rr10d3o30+yzf/cxLxv3Q 6H1LeC51ZorW+znzJt5y6ZQrdfu+Tu9pg6tdci695d2sc3fKWT5jzbstsx7fHmf1ljN4Y0G+/czn Cmz/Jf3X670J3t7uph+a6ZPgcWLpDTgA9Rjoe9Pgcdc8zLgZ1Kujdp3B467v8zhf8E6l82fwuIJ3 cYH/+8GuM3hc1nyzgcNG1Pdl82fwuEsO+K3gayeOfsud90PG+3vEzXw45w0el7Uet+SVexuv8ZYz cSw3z/q0e9h+N3hcFuJAkQO/Bp+/837IyMuqd91AapczPE5x35uXiq/P817JsMvr9GM+fJ/lT/bA tR1wdHoumfy4a94QX5BSeH4HnHic6FHxVA8+eOo/M/lxFe/wqrwlZ17kLWd5kPX7qijk15nf+Jaz eqn6c9rl1M4y+XEVcYd1+k33eL5bjvAgV43rqsjn4vNOePKRJxwD6mlQOYvHRc13Km7y3tH9Z++V yZde28oHb+TMeVYx77gfHs4JwpPfEa/hCK/DLWfvFeH9HHpJhPfgLUd4D3Rd3/E2bD+Y/LjBszDz ytuzfWby4wry8dr0Qz/JmbzBgvgJF9RfQP0hJx43+pm8y57wS91yBI976XqJc72weSD8mAVy4389 3psWj4Mf2gmR5K+bh/yUO87PNv3P/lrYisvQe9PicaHDPx/9B5yE4HEV+Ufz+6gfk+BxEf0F8EdS PMficXHiMhlyja1Pkh93407Ir6L+SIvHpZsHEnFrdP9ZPE7yeO5+n+4Hmx9XG76vAefa7JeCf0d4 X6vwC1/vauDvOu9Z/37m4/m495clbEnwQ/CpgmfokMuvXS6q3T/kA/gS9DyD3MzjI/Hlmvcyzu26 vMPz0g+Tu76rq1/Dz3O3L3JTL3Y/5DTzpICnyl9Mubt9kzcIXk0vAU9GL2+5ZOReKteQ95kjlTvz BjWPUnhmV9z3lLN1/OY4WwTva6FyJ44nfBPKR+Y/9Gfr+DmMsyBfVO0CI3ec8wMf0Z+DKP0dB2jk TH5cAB9gnfU+M5OzdfxC03pE4BGsjcuZvEGJT515LCO+lerT5g1q3bKgeUg3TmnkiF40rwfxZ09y Vi9V1zXq2bRI58HW8UNFzjteWPPqjJx5h4eseWeIBwuB6tPim+XMG/RUzvg11C+fpKD7mx/FyKVT Lom/Fevl5rMycsavEbrOu/LmzXy1U876NSLyj4pDPT46f9avEZriXLmqXKTrzPK7Sb6L4B6Qo+O0 /uuK9Ql8GnlSRs76aYGL6v0psCWRI3mD8t5PWi/tjmc3cjbPrSj/YEL8dWDrmuCbCXk28Hsjn8vI Gb93RD0+xBcgX8bIGX3edR/nO4ftB1bHL6DuI+xden6yvMGOOn6I+61MnwTf7KhnOuv/0XVG+D/V rz/rus24NSNn9JId6qdCL433Z9dZ1v4E17l5OU45mzeo+e/x5rOi5xKr4+dQ5y6ufEin3GFPLHX8 UsQ6Y/cYyRtUnpOBB61x/kbO6LMkPc9m/K5j+53lDab43oc3rn3K2XySGvQdXhz4l15UjvgjNS7W wU6udF2TOn4J9fHwbuTr0+aFtDr5ALGuqT5tXkiDX6oF+F/oOG1eSEP+WA/wE1G9WP9Egz8E9auQ D3TKWXxT8h4qeP0f1xnxT5TXa82TinRdW/9EjAHzAF5Gqk/rn4jwn7XuFzzulLP+icl/lhz8pnS/ kzp+MvI260y2zvpjdfyQ94K4NeT1GDmrl5nXA1y0s3kgdfwieNo88mEd+z6SN9iQb4E6fsCZjZzx D6pd1vScufnPTjmSN6jvP+dhF1C7nNTxK0HjvQPuFc/7M37FPNcL4hLofcvq+KUOOZwTzB5kdfyS 8rtNXIbuP1bH76XrrCBuhtpZrI5fAq8m5p2+V0gdP61b3a57E/g01Yv1Q0udyHHuTt5XOg+sjp/K dcRV0ncjqeM3+5u8I53Og/WDSZzG8C+BJ4rrk9Txky9+90ftCVbHL6OuF3ggG3uHkzp+HnxyHvX/ +Pli/dcz7yWE8nyekbzByUcWInhYqT5tXojPqDPpFB9rdF2zOn46fwX1sqi9xOr4edSdQz5QpvNH 6vghf7NO/gJ6npE6fl73XwUuWpk+Wd7g5HtCPSL63mR1/IKOc/KlF7ZeSB0/j3Ne+d1nXoiRs/5r 7CO555/OXYNTduU/HusFctTuOXFKyefS+lVYn52ulxOnlHwuzXvJ7cM7wOCUqP/nO3D4icMaOaMX rf89HOArrn3KkTp+DfljIX7QZ7R6ub8P7wc67wanjAn++TzzXtg+InX8PPKI5j3d2Ply4pSD1y9O Xsa17pyRa6ecrOugD6rH9wOp4yd5qVKnUvOWqB+T1fGrqtfQUMePytk6fr4m9KfrhfptSB0/j3FG vI/4frB1/KQfqTNaPnyfzRuUk/Gu3znz/4ycWWdST33IecQzUDmLU+q9eeMBcrwQOZs36LR+nKxc J+UjmJw5z2T/BHXsPq9Pez/MOnd3HT+qT5I3iHkX3qYnfwHJGxTcfcgBR2hsvbA6fknnoaYP/gmS Nyjn9JADzlzZ/Jm8waR1eke/Wr/DV9ofqeNXNW+wIP+Bvh8ITllful7wfi/U701wyoZ8rtxRL5Kt F4JTeth1qBvI/cm2nluWOiqSrxEWPPWUM3hcw8yIw1vGyfRpcco68U3U8670fUTq+HnUywLeUSge QOr4deArtaF+HJUzeBUQSK/22ZO/3OKUI/xF5XJ/7s/W8RPezhFvk/Eeo/4QUscvznnQeFPkfSoQ t9Qt2+WyXJdjvaWZ16rn/CFXXrtchF83/+hOcfJMestNvNHieC4DT+1txZmN3InjwfM3DMiy4NpG 7sTxvMM6cx79FSZn+T9nnbvuwVOaqFw55W6eUuCNijOfciZPsXTYLwXjDFSfJk8xyPutwf951801 cgav8uJXdGpn3fFLp5zF8RzwDqd+sMbnz+J4roHPEXmRfP4I/yfyQiJwPE+/z+J4DjxtAf5PT7+P 8X/qPkJ9EvCGnnKmjp/UldT+dL8/yFm/97DnlBZgzF/M9PtInmKVddPLzOvhcjavAHixk/exlHti chZHAF8s+A491yfh/0zg/9S4X8/7I/krky9W+RI8Xy8kf2XeK6gbqHElpxzh/4Scvv+V95nIHXoJ l/2ieFxGfbXaqJzBA7LsI4f31WXO0PVicTzhLxO9qBw/JyyOF7AftB7x5PM45Bj/J9YZ+L2B4xk5 q0/k1VXEF2QuZ9aZ1h8LwLuElpPJWRwvgTdU+UOQ13rKERwvqJzWZZh2nZEzOF7qyMfD90UqZ3G8 jDp3Tt85gc8D4f9smu8767g3Nu+0jh/mHTwunuqT1PFDncI268Swe4zgeGJfy37HONk+Yjhe03UG fyTsLCNn+T9dg17UH9KoPgn/Zwb/tU+f5EjeNfB35GHSe5Pwf0reyshzq2vcr5Ez8VnqlypaZ+bG DU85y/8583PAJ975+iT8n4jXR93czvc74f9Mmu9UUf8vsXOX8H/WivyjtvJ4GjmjF42bKDNOB3HN p9xhl2eti73V8aPfZ+M8cpj5Vah7/KJyRp8Zde78jMOl+9byf8aoeQWzv0bHSfg/0V/Z6g0aOaPP GV8ufBdP9hnj/yzIt8h1wZmNnNFLyKjjV+qCBxg5o5fgUMevI++TrRdSxy81xdHDzHdi5xmp4zf1 6cAH3+n32Xe/8JNmed7KOU/3LeH/7JOvEnxr9N1B+D/VL99uPlzP1gvh/xQezoFPY7/Tfcv4P8OG wyJP2MgZfEV4Rt919TqfB8b/iTiB+Ekvto5fQr5FQ71yep4R/s+SwTeKPBv+fTZeI6H+X1K+mdbY /iP8n1IfdMhhnPR+Jzie0/x+X4AX0/OF8n+CVxN8M52O08Z5KB9Hu/NT5S+snMXfC/g/ffqwj2yc h/pbFzm6Pu39kCt4ShHPQO9bwv8puN8Sd5GpXgj/ZwV/ZFlxGSPXTjmti9gvux7+Typn+T/bnL8K HjM674T/M+v8NbfyhxxyBMeTEfQf9fzePBJGzuArDufE5BGMbL8z/s844ydW/k8jZ/BiiXea9RFv 3oNTzuahCH/ZWC8F/IPsvCb8n9khngH4EbULCP9nRnxIx/nZuJzRi9a3aDOevdN7k/F/4n5ofeX/ POUI/yfiPMpcn2z/Ef7PDHy6Ih+PrmuL43m595qUI1b/C9u3pB5fjHN9I++MjpPwfwbl1QTvXafv Tcb/GcDjiboKga5ry/85TIyNz5Gua1uPr2Oceh5OXPSUs/yfc5wN43RUn4z/U/vTOFeNsyRyVi8V cR54H1F/K6nHp3X/+s3zTO0QguNJ3asbN5448ylncTzx73ahjVH8ga5Pi+OlMOdvrTdo5AxeFWcd P5zXjo/T6DNALx15ddTvRnA8yWOW+dD54/uI8H8G8HiCT5WeuwzHQz3FXsLz+jT5hv3mi23Ibyxs HxH+z9S0P9/XOI9T7on/c+CHOn/0HCQ4XtE8aKnb+MarTjljn6WIenyor1Zpf7Yen7xLBZdLr2e/ N8mvanpP+8krHdk4Sb6h7iw/+UMqvac/5Bsibq1S/7XF8VKDHxrxisjDPOQI/+f00+55iqeczTeM GGdzyJNi32fr8Qm/k+T36HuT2z0k37DjO1P7MA8WxxO35cIX2zb/xDPva5q8mhH13Lb9PvMbSR0/ 1KnI+p1SrsTKmX0UwK/RpXCj+K/X/sqDnLxvUN+3wi5Y5/3+d069wPPPMWt8QdTCTu+8Hv0Hb3wz 7993fVfWuO3U1a9R1c9+yNXXLhfBU5rBd3njzJDz9zgNvtnmOkPdR8VTjdyJb7qGdVZmnmKjcie+ 6SauDf6sqvHlpxypbwi8EfHzwCmN3H4/VORbewWYBedKTM7im7rSnfJlKG0skzP45vjvca4pvqb6 JXIWx+sR+gQfBJ0/gm92xVdQvxi8OEauGLmKOnDARdV/dsqx+oYT38zLvjVyFt9MwDdR58fTdZbO 9VLLxDdRn9JTfRp8M6ndOeoiIs6D9veQJ9zVLrvmL3W6Po9zsCifqeQpTnyTrjOCb1bFV7z4+8RN weQIvqnfh3pgqFNo5Cy+CX5MxZt/vNrJp5zFN/Xd4MHb9eML7Y/UNyxa76ygv0LXi+Vh1Xg8D7/I tJeMnMU348Tt1c6qXM7im17mvWr8r8YzWTmCb0b9vgac2XE5o5eAOn7TrxGZXhi+qXVzJa/j153X Y+QsvukU166Iu8hs/gi+qfZqQN3IRzmzzgLqoKo/RdIAiZzlYU151t9ccUojd+jT470ZtF6F0/qm Vs7im0HihB34Tn5CpvNA8M2J3wLfpOcnq28IHlaNN57v21PO4pu9oi5iBt8oW2cU39T97jF/dD8w fLPqeSZ/fjrPGL4Zlde2ow5O53JGnxXnvEO+tvo1jJzFN3PGPKgcvf8Yvhk0b3fWLevsXqH4pvKR efCUVipH6ht6lWvTvqbzQPBN8F2kCn8PXWcM31T8r4AHOdN9RPDNojx0MQNPpfNn89FzAC4Ku4DP u8U35edlb2W8UxPdtxbfdA68cB78g3Q/WHxT+XAHDyTyp3l/Ft/MiuekmZ9K1xnDNxX/y3jnyF9Z OYvjNZVLEf2x9ULwzegUr8pql7fK5p3hm07zaMNWF9HIGd6DWCYPncwf6l2fcgTfLKrPUMGTT7/P 4pspxW1dBypn/SGSn3hNv8bjinqZnK1vWJBfDH7vyNY1wzfzrHe28lkZOZtfDH1Of3mi/bH6hi/p b9aBC2xds/qGO9740J/ly4vgOxwFON64vZEz/BrD0S39aX5Ao+8/gm9KnawhN+M16Pok+CbqgRXk w/J1TeobAv9LG/53yll8U+L8h50mI5Eyz0zOrDOtb9eUj/XmhTNyZp3NvGRfwWvLx2n0mVD/b+7b Tvuz90MBLhMQF5vZOUjwzQT8KKi/riW6Xgi+if0QIvAAep5ZfLM71afkh9/xg0bO4E4N9c78xIHo eiH1DYHfJvi96buK4JsdeFxD/hj9vuf6hupJv/mXjJzB8TryPifPV2DzZ/DNKoWF7jqAd/60kbNx CQ24aNHzxTH7heGbXuOJKvLH6LuR4ZtrvuiTXcfqG9ZZD1PPl8rOJYJvNuT3NwechO0/hm8mrSPm gP/R85Pim6rPAn3Sd6rBN6vGaSz1BgOVM/imrrOZ/+KEFoLJWXwT50ubPDx0Hiy+GdvMo8U80P1g 8U3v1b9bkEdL7RBW3xD5or2u8aZGzuKbXfHG3BE/QcfJ8E3FG1v0H/o78xQd4j874jIFPmRyZp1p vEXXOIGb1+GUs/noHXUK0+QTYOcnwTcz6iJqnfRZT/GUI/imnmc54jyj9jzBNyXPSfLE04d5J3mK FfmpiEPydP4svql5kW76NYA3nnIW38wOuOhcL3ScBN8sWC+5PssZPtUOPtwugIycL+z7GL6ZITf5 pdi+ZfUNwU/bMc7G9MLwTaf5xa5Bjo7T2vOSPzTWy+S3eTE5a59VyOUpx/qz+GbuuG9nXQx6TxOc KyieGhCn2ql/1+KbadYN7B38imz/sfqGM58rA5dh80f4VCtwmdDjgqcecoRPdfJOSh7EXYfxlDP3 Snfz+4A70feKxTf9xGUQX1eoXW7xzYL6hmHyGtH7j+CbMt9dwjbUbl3nfeKiJx6QFU8RHGniAeu+ zVPO4nEd39fh393exW+5E4/D/xkT0Ba838jZfMOs8+ditHjcLWfxuDjnD/EoicuVUy7d/BpYL1Qv Fo/zWNcZdRh9p3IGdxL8p0uZu9evmyfRyFk8Lmk+V8C8dzoPBI9zisfNd/HmL3/LWTyuoO4c7KxK x0nwuIh6ZzoPzdN5J3ic03ygAD5xT+eP5BsibzeC32bD4245i8fpezioP8xJuRkmZ/EjjXuCR+cn 8XVt8TjUd5I8C3M/vOUe6hh51LmfcQJGzuJxwHNmXtZmD77lDB5QovbXUTeQ73eLxxXkEZWC/D86 TlYvC3UY+5pveMrZfEPJgxU5xXMq1SfB44LiYxlxVpWuM8sbqnFkMz5P6ESIHMHjkPeZgMtsduRb zuhF8OyBQ8A+S2zfMt5Q4HFyU5339FvO4k7AOyr0Qued5RtW1afWO9d8cSJn9Qn+VqkD5/W+sHIk 3xA8C+DJ99t75S1n8TicL64RPO6Ws3URJS7L68U3/LSOrWuGxwFXK+B7CnT+bL6h5oGFOw63U31a 3lCXdb+XWTee6tPWRVTcb8n/o3qxeFxAXcS7Ljdb16QuYk/A+/EurlzO4r7Ai/3MN2TnPMXjMO/g qaHntcHjBq6m/Oyzzg+fP4LHIW/w5suj68XicbVq/h/8rTvO9ZazeNyUi9Xif285gscpjhfgD6Hn IMPjsn/d/JqP4yT5hqhDFfPKL3zKHfb1whs63+F8nRE8rgH/07iuVug+snic5FHOPJ3Tr/iWs3l1 XvNepv+a2ksUj1McIcX0Sc7o885vBI7X2PokeFyacqiv1pg+CR4n/Qw58Eg0Nk6Wb9gz9AK848Xk LB4XgTfO+gj0PjJ4XBEgRusmqb+g0/4IHid/L2Ux9X5n64XhcagnhXrX4O01chaPm3LI232Qs3hc 0nno4KNOzK5jeBzyPpu+czq1J1i+YQAvMepQ0XuF5Rs61D+qK2+okTN4XMP8tVkHgI7T4nEJ/c08 zM0vfMuxfEPFH2pBPiz9PovH5ahyM++a2i8Ej4vq7/Fd/Ta10XVt8TidmTbfK61TfZJ8wwKcK8bn dyPD4+DX9xE4HpUj+YZu4nGKq1H7heUbAm8MqPeZaX/nOd8kcEXiCxCnQ+0Cisfp/EXI8XVG8Li2 1Ek7/a23HMHjAr5v5vXQ+SP5huD7jeCRCOzcJXicQ97ErCecWX8Ej2vwm2plnQM3fMtZfUJOePPu /E0jR3B0xavyjEtg80fwOOXXHwkNiD9j5yDB40rQceaO/E0qZ/E4ravQJUH4183rYORsvmEBDzLs QepnYHhcmXH+4ANk65PhcbM/nIPUnmf5hsi7bohjaVQvFo+rmi+Tw4z/pOMkeFxCfiPq5vJ1ffKG jvwvxYEi+H7p/cfwuAK8qgMHYvuW4XFe8Q71Nxz49FvO4CQO/MkZeE6g80DwOAecy695g0bO4nFJ x5lQHzZSvZB8w6TjjBgn9UeSfMPZ36yPR88zyhsKPGfym9JxWjwu4TyTc+nESd5yNq8uKq7mOvBU dq+wfMOk4+zznKfzYPG4iPw4PZFn3uApR/INwdvb8E7l+4HgcU1x+9pInMeUI/mGcc4DeKzpec3w uKDj7A51O9k4DR7n1Z4b6wx+G7qPGB7XME7gt9SeYPUNK9ZL+bBeLB4XEcciboJH/xnhDc3AH1r4 8B4jeNzELZLuo0btSFbfUParl43xiMsQPG7mSaGOX6V2Fsk3VN5JP+u418z0SfINw5QL3eJ4t5zR C16Eg39XcRn5KyNH8DjgOaGDx5OtT8sb6pA3X5zaSz2x/li+IcaZZh3Gdd5nHh/JxxPe1uiFGNPk y9QHuZC0rkxIiGOadRGlwML1hLm2Vb1eQN6Hf/jT/6Bff/v7v/z1H//lv/0vf/m///JvP3//t7// e/Thrl+lpPHT1+zWn9evcJ1R+U8+xehKji77P7lLhSH96eX+PQZz/vovf/v7n//19frTX//5z//p 07/73d//P/TXP/wff/nbf/mnv//t9b//87/+by+shn/48z/95//4V/9LflwXxz/95a/Xcv6//vxv /+Ef/9OlrF9/leX917/8V/n5z//0f84//6/jv/9B80zfaarHttA/h6CHTMjzsGlqxP5Weph2AaWJ ry05S/ho6ulvpcfDRRLjNcEWgRVFA/1+I40LL//osYwyQnf43W+ku5iP0vcYQ51F0VAM9nfSYoRc WvMSetQmRRdK0BppTdwxOpcLc+i8woHCtSb0+UR6uLMuab/RkZ3SBiYZfy5K2jqcKdM5nOh8Gyea EynRkkBeoCguX/UtWmuTYDxqIqmTPI7fSytg0CQqUKSLlicu6n74jbSaD/lH4dciOeQ6Y99I6+VV 1ASWqwvS6po7pY+rTl2mWR3wAqBqYlt2VOenA2vOmNAqNA3P/3XT7p7Sp/tkSoMUQJwE78fmb6RV 531SiqcZylLo/g4u8ZUqBCJjnYNo37EdegKBAIg86KLzpLFHGetT+nQz4rulGIeQqW/F3X8njZUK SnuNUfmlFQ1+L61fcu2tgC+4DbH0jbT++V3WtXqYt1RrpzSeVUo+Nh4NSYOrIltrp/R00t+pCB17 LNP5PqRxIo+EoFlYCIQebH+fQND93R7pmBXz3dnZcsIQuueSvMlkryE5r9HvPqX1dHiHIqaZwlbY yE8o4z1jAGgrCjg5Nt+ng+W+x+Q5M8qtIGzPs+8+n+mQbkriFjSKXEA7tlINKYbuUFCWX6ZxjaDw eH0hPU+HqoGDYSbG1cq0dkpDD+l6Z6o766apYd9tpFUPGY/w9oMkapBr/kb6bTsEhSyL7hKkVv5O Wl1rXROtBiHJBkD+TlodO0Xv7Us6Kg1bDVT6cOMtVg+S51RrnZ5rudIdmjX1SihzUcKS9X0+ue+7 JCBQFAlxubG1dkrrnrteXxKmXYQFQk8HNvL2OvqW/Z2VXE1uBX3058BWy/nY1JHfFBR+2g5w7Rvp MzQP99jAXn7F64TCDqU2Uz9vYJXO6tYKfd5jLa2nw6S7OW2Hea5J0PeltT5JEF0n0k+not76WUtJ vEMZ/T5y/jaISZgox3eXhsC2/pX0sHrjMD3wNugIb2tfSY+1FUfySRVpBVekNtTvpXUGY5Ralmqf q6tAQzV+Jy0zGLMWjrikizhsZ6FzI82s+yEt5YW6xG1L3/y7mXUfkzr9hjSC9LjWqHWvlcV0h+pq QYj776Rh3ftZ0KUWBOiWb6RB0+nU6olimA/bQdMOfiM9b2B9l2hu1OsNRv9GWvd7lQqIW0pAozNG LewudVZfWghFAdhMv5ta2F3D6UQa5Wj5HqMW9iy+Ms5zBXVKZPP9YCMHLU0zoXwnDFdEmlq5wwFX dcZCwyuW9k2t3DFysfrTpPNFuZrfSc+RR6dBLl7Bs6ogw++kJ1V8vSlQQY3OdP5g5SYtaCgFLXXk js33g50abnruSSOnNtMh/WArIlhbgns+9P1gKzYtlRX8LJUNf8spzW3Frgnt4X6XdNr3g71Wfzqs n4IwGs/22IO9NpLoJ1iDoBg2Yw/2Wldod5RCUy8VKKB/Jy23XgiCSCigosANXancXrvhMJRhuOH2 U5rba12TAUaSG4KBEtU5t9cGZKupVbNvejpwe63qrXcHpjtNgDLS3GbqP0hwGGVtdKU2tta4zSR3 qN6CvaPoHZsxbjOJq1+lERoR/KrzmerzZDNVp99f8fYvbp3vp4SfaWkKnfmwuJp6Jfdb8IYnqJdK yCyHtQMSDycxBVaae0wum2nU5BGLK6nFVZn0w2tuBDYWsThjXQsDhe+01sRWrKANGtdZWKQ/ay3h bVA0KMFIP5FIzreBhJr+GkwP8HHlVfq2kaknOOjjT+x0BF7p2XJKP1rY+t0eafhFwx8P6QefRxP2 PDmRQTKhZAqHNN+h7WeCvtdSVX+L+h0gPSG0x5GjkJ4QScldss73fQK/dumgI4LPo2hZ+l93mZB4 zDdf57MobJQq5b/upLNDmvtbRiqXnjGa5HCH3BzS3O8giQIvvUMLLI+ySM+19rhS4dPV8oV3+UhI l99ISzEcOR0QxK9eSZ3oR0/w7qUqWHP3WvuN9PQjtzALhmlgVNZz7ZDmHtH+c9ttFfSN+gY+pJ/u Etege6d7LCvikT6vFm1tpJh2+dkyUjdTZNJPWkvzDbzhRJD+3f6uMvKi+NCvm0YyfTvfs2/sMf8i 0qfXQvdc1pSuS1pOhbcXOn/33UrY8O57L3T6u9NBwjBE+vVaTuR8fDedsS4cUlrkcwZfJiLN9/eg Tn3pWsN8w694SD/5elqfiakauJu3wgjzHnta53WeUA1lVOSvTzrj5x2K1YJgj7IV6frdWhNqorFb cK6V/o30vb99nPs76v5mxMjnea5azFq+RVAHPdfyVlbu6Sa6vXPy/0eOClbqRsb9tNZm3x4lYeTf idZWnf9ujzX4AFycOm+LdP0onbW8h9yC80Rew7LmHguH1lSLSR5UkpyadKWmLdj76R47V0u8SxWy 1PLHdV5mQJK+3vMW0PJbrUWdsQ7a9dLXvj9r7ZKWt0FVsoa3zsUNX3v0vl0nfiul/Q8Livn/o19/ +/u//uOf//7vGv7z2/gfl9w7/ifVEf9zrcf/Gf/z3+PXGf8zVgMJ//Hye9iCgL4M/3HL76sjUF2e I0YVNYgCDaJZf1+lHZizPDIDEg+DWX5/Sw++Lc0naYjX7wyMwqPvePolr9U70sjqQzT8c/CQcQRW zb0eMANyf9X9SKWj30eer0f+gMmzhnBLRgTVml9+374bwGdH/REaXODD+vsirVVZmqQT/rqrpBrp tvx+P6DSjxuuoBCluJxI0+8WufO7R8jRCEkI5c4I58EkKn2MPHgJNB1jSOCr4IEsIzHV9F2cZqHk Jrjhr7uq1ykdl983nYPbryEngYfgpOX3TecJrYAxytGVmpfft75zw4whv5LukhF2bb/bK8Bd/Hu1 0LVWlt+3HYraeXXGrPPQo9fLGpaSqYBwEDAx8F2ioNu5WqoCf6GKbSEjp6tFqjOa764a/lOqlE/8 dWcBndIK2Z19N+UGHuF9DjWMaAjO8vv23cLEee/UydR9SsuDmvTdAQA6jTPn55qeSQbgKBKZJl+A 50tm61zlSN+SyzLAZnCJZqY1lT6fAqFoZdQBm4KBNrIdGpff6R6bPOUUJtdz4Rz5ACdQlUmrfczs ES59ni3gjhAOOeVuic/BQ8Yc76g83cUCl/nm0nSdjzwLharzrC/K5lvzKU/pAXAPR1oM9/4ubI+l 5ff9ZPKqtTq5Aal0Yud5BMP/cNaXtRLrIZ2X3/e+J88c+AloUMV04jWjtXGORydlHt8uQCptRp7V 1RvLT07tWWsqfboRY9bKmdFJyaN3eMAhXZbfjxtYw9zqDB5iWsPuOk7k4ZwXKCshu+5HvK4P0mat Ra19O6Tnd7M9hsf8ub8jKsJFMKH/6L+30mydD5tp5BXFLl6t0Xdl0nX5/VgtqN7UsFLZmaqhsmff STf0rxS0hvPom53nbfl9P5n8PM/98w3cOjtTU1F4PE3ekFlH75Duy+9H35o9W8FqQ+01BeHMfI8g OQ3PR0glcscgfUM66+/7/a2Wh+akaaUvI/088hliF1deXEjfzstH6x5svC2vrM+H9OMNHJATr7UT jhv4duI9WdgdGeANmeqblTulH++xjrq6HjyYW7D37cR7ss8bsrMbskO3735LNzJjAeEQ13x3zNgW cL27ANltMO0WZP5t75LbifdoI2fkM3dvLc07/2/5fbc0I7KoG7LLV2vvdmY9WdgNtVTvtZaJ9MOJ 3FFxst1MXJudev+7J/tceEGGdKh2f89/93yu9Vl1ti/ffYb/rL9v67xoKwEzpvc3DVRj79Bxb+cR Kv9atEaDpsjZonZqkUJQ71BSK/3wHhtZt7n8pIyqNDRA7+lVI6F143WjkE6noQmPL4s4ztLxskBY hMJop/Tjy2IED10/K+ptc+mnl8WgM5O+w/qiogFbRHqgbsP6mSkRNKji0bqXkIwRFhHw/mY65xb2 wgOgiVMS/cSkn6xc1eb13ajeQKWfrFx5f15WbusfRv5op/rh8xjBkfA7ZDZjz7biOIljkUJw0jcL Y322uJLaTGCfAZu5kaY207hDitpMqLlNA1GfrZ4RQppQSe1mKjukH+0WqcOViiTUv8+1MwRn+f2w W+YNjNc7W6mPdovAKcNuwV2SV60doSin7dCV8Uwy59NynvMAnmPkd13mUch2rRtxBvBQv2IOEgcz fHvVr69YKm2CQpLWCM7jNbfWZgi71j54RFXnFW9gtR0O6WebCSEpFbwNYQ2DOXRupTOqKc/Xu76/ j/AfvLztjLUILg1wjPg1FOUIU7d9y6koTPyr7XBI85fkeJeMlRq7hunfXkkqbd6CTWhex8+gVahw Ex0hOJjpY+QjUAupAX36uERr8ZjvR08wKjoo08Oc70P62d/S1Orx4DvV4MAjiIb7mcbbV4L7/V0V KZdHaQMaOyHVHue5i+Bi64v0Ee51rJZhedSOVywqIazhP2WXflnp8oK0ai2yMJhH+1wD66+f0z4P VJra5xneuUF+B49JfZY2oVPXLejVfoHloTNGpY2PKwm6LH5F8BdmNvKHt0GXuD55f+NELqv0sb+t dJ2cPrhLtjCY41VzzneV3ADxxuLtX9bgoSOs8eg7VvUMxpEoptKaLp0PrT2+auYrdmOvOqSfXzXw DFakJWg6xhHA83g6yCt2WH3TI7pKH2eLM9LinYrgXT77PnbJ6WfSuEa17vVkyiyA58FTlJQTa0ij houmcpZD54+vuTD9LWXxtxzSz/61inoZIS8+zSOA5/F0cF7PlrlD+xrIst9EZo9FTS8bSfbAQ7ca 47s08SNX3GMprMxJh/TDOi/qMRl1x6ff4bVIH7vkXC1Vz9Jrl7i5S9aR32NUe+fo+7JbhHsrx/sV u9V6fb/mlt+3MxUek9p0nctfnNLPL+gKnri24qGQPqw9gnAlVEVKOJnKozTxmDTcBuqtOrjtDlvx nLGsfY4Z88CBV6alQ+fHjF26lvCf62eYfgeE4FwKCM377LzrybX6P0Nw/l/+a0R8/DvT/3yO/wk5 F7/E/4z/78f//J/xP/89ftn4ny/of/5Q5M9yakkG2ggBTAgMrsp/d8idp11CcmUS+ns5pymmbs65 y/jTAM00E0so2kZ4u8o4k0cCNZK+Go26OL2iWt989DeD7Dm9TjBy0lIVh6bKfYqsmXIziaMhfNXL BfwYmbL2JwkI9UeZIkd/VJ/JyCUNyU+tfZI7bukkIJhSo2h/lSLstg6SRx0kySaSJBVKhvI6+8sS Oj6THtysS3vKmTBu1CeJWv/jcxTC2p+sx+tnxDz4yPo7bb4sLpvxM08bv1H6jtcp55AakUv6oJfz TZGQeDL2A9LTaBSVSfIafM3KQ++BidH5O+3ppL7WX0qXr/0x5PV8AygtvyRlzbpLlGLjtOcSSIOK sB3pOmMY9Wk9X+sM/U6KplKZ3OmpzIruje8Lcx+t83BgpOv67AHnBZKQNrTMf+gP51mIZP8duOh2 vsx5YPv2MVAd6zJpMv8bp+FY6NqfpK6s50QlcmQfBT3nwcj947fIyncyntvktCzwa00Y3VDXt1w6 5FCJyWvd1zsl2sid566vSIdympCMunWnnKl7do8zaxxi3eb9LVdOuZkQ6wJoQOj32XsFdV/EBS77 j1F4nPXSBiSoLz19Hzl5mjG5XZ9VuJt0nAXEWRy/PmgcnDjK37Q+03d9yh382cMlhDpIqAde9d1q 5MopN+kmkO5SM+3v4MHuskxULxpPKRAakUtmnPrd14ZQvRS6ro/U+3ucXgwZE7d6y2Wjl7u+Xocc XWf51MtwHqA/pJTS/sw9HVAvTVM7znP+LbfrU+q+aN06eGNDSVRu1+egjcj6M8UVyzRy7ZSDJSQO rTdv8yln66VF1FmrqJsV6X639dKiYDFRCJTfuOcpZ+ulhaJ1ngoIbCLVy1knIWqdnzFOjR71kX7f WSchCGOK6AUR7ZXuhzNlPqHOnQcfvdIsEjljZylWk35wLrXG9HLWS8tYn1XKLLze6ZhGzpn+RJ9R 61g7gciYXDrlcsA8RPXwVLbOTL20AOKhOM/5vtkht9xpZ139ob7XrEPd2LybemmDDizg/kO9Lfp9 tl6a1AeS+0i9SIWtF1MvLf7Mc17twh9Pz11SL03i2YZewEPv2D4y9dJQ91EIONUud3Tebb20OOvI ZfC003kw75wQ1X6pdb4b6ThtvTSt3zLmHUQlvD+zzuR9OuqlIUfAs31E6qVpfeegcSWP33fW0bnk 5J0T7nOJ2lnmfVQR7TQy/+CzpPvW1sOZ2Tq5or4XXWe2Ho7Wgas36YxinEbuJJW65lvfK6nqevF0 P9h6OA71mmbsALUjTb20IoV35X0ERDPS+Wuvc50ltctLx3us0fk774eC+ghV6R9v2gkjZ/XZUW8L kc/0fjD10t71kzyitT2dB1svTfaB5HhpPSNP9WnrpWXE5IEIpQX2faReWg6ql0l419i6JvXSclQU Iat93SJbL6ReWo6qz1kPrrP5M/XSBs6iFFRZ+flRZ83IGb3ovkMO2dN+MKnxP1pJS0EDOa/pvjX1 0ppGP0ldnLIgO0bu0GfVbC2JyQBNJacObKecQ537Wf+K3n+mXlqVgqsSy1g+7AdTL61qTPuIPMH6 7GzfmnppVbNURv0y1N/JVC/nOV+FsU3mL69xj0bO7L+E+np9nmdsH5l6aaPwtUa+Z5+e71tSL23W 32kd9Z3pPjreAUXMZKXbVj9Kpe8VUi/NV42bgj3fIu/PnGda76f9JNSfq7w/o0/fGvSi+2/zQ99y 9n6Y/aF+58O6tveDfl9713+k58R5zmdJdNA6WCBOofN+1sMZdT9m/TKlwKLvTVMvbVCGKT0d7ulO /QymXhrqNM36RHe0oJErtD+pMwN7gunz9H8mJUn+paHqohdqD5511t7rs816KnRdmzprXevHBXXw /brrjRi5dMrlWUcnk2zdt5yZh4D4Ko3Km/WoTjlbZ60noOEJ2WRsnZk6a13rWo4oApc/zMN5P4wY lSjrzSu5bd/yNN5yRi+TBhH3X490nIbuUxhNVT+IeaP9nfdDR9kDN+mi+f1g6qyNcaJuFuw63t/x fig/evKPwD6cg3Q/mDproz/MP+oKdzrO817pqFveBXgyeNVb7ogKC5JOfNfB8kpHauVsnTX5P4MU Efl3ia5rW2dtyk1cjdoTpM5aDogfx/qkdiupsyZ5keM8nPGZdP5snbXcO/pDLM6LyVWjl4RM0pmv Re8VUmdN9CH1y5DlTcd5vB/Kj96I7cZFuT+Z1FlrqHuGekZP/Zl1Jrkyg3IO+eT83LX3imQmyTyA TJL2Z++VkRY6xhnwHuPr094rYrdc/SX4C6i/56yzNvob+330hzqxtD9SZ00yxWUfIVqezcNZZ03O W8g55Bayc9CS0V0GvOpF68JpnVorZ98BVam1otd3Vd1yV285a9cJFfgwJ/oHubPOWhE3rfQH/LYm tm9tnTVF6AYOqBRgnr6rzjprI60GuMUs5BDYPJx11ipKlQxaYlBnUrzjrLOmKf4iB3yzUn/5WWdN yyVDrn6QS0auor/waf5snTV5P0t/mideM9PLWWdt4qFDDoTD1C63ddZaBKW2/HnEJaxyRzbgileJ ZVIlBPRl4iD2PMDNHhRcLYNwzymd2S13ZACu/QmtoT6TFLd4ETmLayvlaJZyuNrfqs+3/W76K9pf LhO/fRG5Sr4vor8X+qPZdkbuxplRh7PzDEFb7y6Pczc6vD8k5ZvImXiUOu8jxNugLq3JrTv1EhCn c/v11T945qaZ79MTYPhr4SdS+4zmtG24RWmKP/S41uul2WzrOHPEvMcZk83m4XyvZKUgHt+HIi8l M32SeppqyXbUCRZKFStn4ydS39cZIpHP7C0zzoD4kIZ4lEK/j8UlIC4ozX276vM5DqIIjj70g/iC LYv0yBta9Tn37aSn3NZLeJaLioeXO55onYcj5nbdD3H4a0ZpBK9FHba8zXtd2biEWY7Ja5GbnZL5 LZcOuah+oqD5czfOZeRMXEJHXEJRewJxEKecjUvw2pL6fTS1iMmZuIQAHKhp/ETZyPBvORNfIDia jLP5D98XTr04B5rKqu8HEIsaORtfMOzOjpIm97v4lLPxBdpSnO8xEDwaORNfIHi44LEg6qfzYOML MIKJj9XM5dIhl2T/DHwT9pmjejHxBaljnXn1u1WuTxNfEBvkIuI8Ml3XNr4goohfQNzMlrn99pe9 znMJRNmtzPgC2h+JLxA8Teti/RoM6XTeSXxBVNyw9TVOwMjZ+ALg6AX4WKbfx+ILtIxXUNJ5x88X G18QhG49yML+pWEbRM7GF8h7Y5wv+r71jq7r8/13fVfWOIiGjKbC+zM4pdBGCw6r35foOUHiCwTn 8ijYJc9AJmfjOOUEj7O0aE9sH9n4ArUjqiRNPa8zEl+Q8+wPGepczugzI34Jcbh9Kx7zlrP6bBqn Ot+p/PtsfIHg57I+6+LPMnI2XiOoXIZfqrH1QuILJA989BfS4pcycmb/uaZyqWO90O8j8QVVqeF9 g5+BnWckvkBYHWQ/tU9yNr4A81eQ31/Z+iTxBYijrjN+l963LL6g6fcFlFHh4yTxBU7jBCoy8ui+ JfEFLiWsF+BVLyZn4wsCzvmCPLrK9juLL+iK97u6ciWeciS+IGmmpavADen6PM/5jHy/S079163R dUbiC5Lif3JTOY17tHIkvgBxCXchGy5n4wuy4n8h1cVffsrZ+ALYu/XOf6DrjMQXoERSwD6i9x+J L/AFBYpmqR16DrL4AuDayPkMVC8kvsAD5wKOztenjS9IRf36br7f2fok8QXFIT4EJTfoeUbiCxLw uIn3R96fiS9I0GdOacENTzkbX+C8xkHAjtwLg73lzDoLHTiz4qKI8zjlrF9R3o1F9SHzx+UMjt4z 8Fv4d+n5SeILXJklONWvT+0XE19QNG5i4CseJcepXkh8QddMT8Q176WU3nIkXgr4EYqUN7YfSHyB xl1UIZt7xwkYObP/cocc7B66b0l8QUach0OpKPrOIfEFGaW1EuwJ+u5g8QXAq2C/NHpOPMUXDMJO vAMSHSeJL4goD6ysTS3QdUbiC+RnU24VJzAGk7PxBVHxnIzS9nweSHwB+MAS5Oj7yMQXZHBpN43/ vfkZTrnznJ9xLGCre9xHZ3yBVneUddb0/ZDp95H4goR4FODo1F9A4gsy+h0Q+6873sbIGRxI/JgD f/fIimd6IXECGic1AATRZ6b+CRYnIOU7vVQX+nXHHRo5gx8l4NqxwO5h32fiBJpUm1Qeuf6sTxYn MOUnryTtz8YJdPB4Fc3PcfScIHEC4l8YOGfG/LF1zeIEKuIuUHI48P6e4wRgl9N3DokTiA64aH0t uKGRs3ECwH0Rt7YzVt1yNk6gAK/Keg4Wau+aOIHrfPDot69cy0bO6DOAaWnGpVN7gsUJeN1/AQzo 1L5mcQLgRkZ58k7f7yROQM6zEVcy31V0/9k4gZLBjxvVH0LfjSROoHjdtygoCk5fI2fjBBriBMCh GKleznO+C5GM/AzgX6D79jznuySIKicO4sTpurZxAhV4I4qW5k73O4kTaLr/csJ+p3qxcQLC2j7m byv2beRsnEBWuenXoHYyixMY8z7wcJwTfF3b+6GjqOnkuQnM/3LGCdzF69206zq9H0icgBZgdz/I v+2Jy9k4gVoQz1Kf3+8kTkDeb7JvtZw09UuROIF5LkWN7yme6sXaZ5IfN4iegHPR/kicQMR9O2ow y/pk68zGCdSu+e/e4T6i77EzTqDNPEOv/lOn9qSRs3ECTf+Pn3G/hZ67JE5Abzav9p2TMDsrR+IE ptyNxzG9kDiBicuEpMUd6X63cQJlfp9X9qTS2DojcQIRuFNQ+7pUdg7aOIHaFS+uipTPfBIF8D7y OgBvvPOZC5E78eL4oxZi+olN9Yl5h5yf/RG8UUtWlZkPVFamvnfetTv0Eme+r1N/HXBfI5dOOdWw 03fZPX9Grp1yEtfjcV47zYe3csc5UVFEbMipfQYcz8iVUy4jriTr+0H/xsgFo5c8v0/9WShWZ+SM XjLyWrP6aR/0YuIS1KLp4jbVd05ncoc9eD2nOvZfRh50yFTuxEWTxAlIycr6QS/pxEXTLMM345Md nb/DrmszTiqo3/xx3tOpF40Hk7wz3beN6iWfekmuz+8D7svlrF4q+nPhw7yb/Zew31vB/tsK5b7l DjvZC93fLzUP5P5T/4SRS0YOeck5rPGfRs76ywUv1ERfwfHofj/twYBaOeMC03Ow03Ge9mCAX8qh LoSYW0TufPcHzcfymnj7xv+MnMER1D/hpDTMO4/IyDWjz4hxVsVTG+3vtOs88iJHoJu+OzLd76dd N9jJFW8MYKuObP5sPJHg5hKnhXMisHVNcEPwnLSo5yDi1oycWZ8J50tDPHvhcmZ9pqTrsyO+VWtx GDkzD2JfjbiLgPcfOycMbuiRp+G13sz9HjNyZh5SaZBTe77SeTj9BR7+kGFn4fvYejG4oVcm3TH/ YeXENXJGL8ErziV8PHce0Sl3+gve/YkF9qjP01/gtfKMfGf/IGdxw6jxkeK/fOPTRs7oU9/9/s4P qFSfp79AA53kHARnPJ+/05/sJaBI45D88p4+5U5/sgdP/OBjCZ/kzDmo51/WqkJO4wit3Hk/BAk4 G3IR+F9ido/BDYM4uiWOEP1VOg/2fpD8vUuuzrxIOg/2fpB7zKcbP+p0v9v7oXsdJ+wX4FWnHMEN cd8ibvRhndl7pQsOm8Qx/+vO3zRyVp+SJ5zU73Pjt0bO8iyIHyX/VMVzKrV7DG44+CBeIge8EXFP Rs7i/ZKHmTUfxen70zKV2/gQjS/IN96huJqRM3pJUccZkf/n2bwb3DCIobWua8++z+CGAfdmnvHs zbH1YnDDIPXCdZwqF9n5aXHD0DSPr6DUt/dczsR1BbGvyozXaJXtW4Mbph8flb9A3h9O43GJXDvl lD8iT/9Z63Sc5/2QxLCS9annZ6PvFYMbDn5xnb+CeBRqtxrcMAHnyrPS1cM4z3M+ScCiyq34u5Gz epn7L6I/tv8Mbjh4WKrMQ23YR+x8MbhhVPbygeM67Hc6zkfcUC2Gu7S6kbNxcl2/DzxYLdL9buMH 1b+U1b847hW6b238YML6dOBt4vvIxg8msctvzuwWaX+EnyirPh3WC7WTDW4Ycb4UISZ6xzMYOYOn qj+kaDyZmzVJjJyJg9CasUUrY7hZmfKUs/Ehek9f/cUPdqTBDce8aRxSQCVM+u5/yi/uch2pv4eN 0+CGs+ZWFUJBea+w9WlwwywJ/RIv4D68cwxumIGPXHpxecGPTjkbV6LVzVB5yU02fSNn9OnB4wK7 vNH3g8ENE96LdfqhW2HrzOCGSQxH5assn/ozepF82CFX84K/n3L2nO9y7hat8ftkZxncMAtgJHKo S0ztOoIbir+tq39I1hldn+f9kCXRU/rDPUbtLIMbZilEJ+duyp/kTBxEk/jkqnlEdzzYKXfeD0US ze7qgU5gMiZn4kq0httIJEIcJx3nec5XxI1WcSj+uvOSjZw5zyripWLH+cLljF5qzdgPr+dzyeCG RRLJRQ58Hnz/2fjBlqYc3n90HxncUK6tXwpvfjjPCG9F1CoMEbwq/PvO+wF2y4iTU39IS/T77P2g FQ/brCbbKl0v5H5AtUYPvkPl4TFyZt823A8z35DaEya/OMvDVPms6nN/BjfMqOJx883w88XghlnH N/pzn+RsfIjy0LWZH4CK56dcONeLWl5daCsW/O+UI/nFUc+zmfdJ15nFDWMC3hg/3bc2Py4X5EFn 4LDUj2nzi8E3qsTJbxzvkLO44aycIQ7vX3d+zilncMOc05R7qRxbZxY3RP6RUz/azYN8yhm9iLtF 5Ga+Gvs+ixsib8nNOLnq2bxb3BD5VU55UpyENRA5oxdUQRFaJGsXzLxk+97Uf39dY3gH7HbWY759 BD/pqEgn+yFs99FRTWezd4PaIXHGF6zjfOcbnjjQ9Lzr++rGU43ciQMp34jkcym+sp2Db7kTB1K+ w4Ezv7DO6Dht3iA0fOPFvD+bN+gnfqR2SNn8Z7ec5SXWfHsvCbvyjstU7sQNewOuVnRdl+0cfMvZ vMGuOMn0Y27nyy1n8waVtzep3Xvi0285kzeo+G1UfioNPyRyJG8QOF7R+MiaaX+Wl1jfqVHjJE+8 8S1n8gbLXGcJeXx0/iwvsfClL3KNrjObN4iVPt9xD99HcEP/UtwQcQKNjpPlDeq8A3eKjvdn8waT 8puWiefQ/UDyBqPycTZUEY60P5Y3CP5PxGd1ek6wvEHtr2s+swtUjvASi93q5aEp/jo6f4SX2Gle JOJ0dpzyLWfz3JKOMyDeLVA5kjfYlvPMS/oukzN+zNTVf43Ko23Dfaccwf+y5qPf/nLaH8sbRJ5i Bk4Z2Lx/yhsE/yfdRyxvMCuP7uTxzGy/M15iiRMOWqf6zv8zckafmhd5nUuav9I7HSfhJe7oz5H3 2FvOrDN5t9/80gde/JYzelGe4Ou81rgL8LqfciRv0CWc12u8opGzOEJBXiTsz0rnweB/0ek6q4gP AV+skbP6dHs+7OYnesuZdaY8dEE6lPOMy1l9Iv4FfuH9XXzLkbzBovu9zHcq3Uc2b9DDz4C8rN2v eMuRvEFUj0O9nt2OfMuRvEHkA8Fv0+j8sbxBHSfet93T7yN5g03ff3P/Obr/SN6g1/4CaqUGdv8x /C/oOot49/P9R/IGkRcZEKca6fcRv3CDv7WufIBGjuQt6Xu6zbxBdj+wvEHw7LkEflO6XkjeYMY7 QO2J5pk+P/ISw3/G9MJ4iZEPVDSfpNHzhfISqz4z/KbUTma8xEHzemAPNmrXMV7irOusTR5dOk7r L4j6s4H/unu2rgkvsWqqveOv2XpheYPgfS3Ix6PnC80b1Lh7P/OLqT4ZL7GeL07fHahcb+TseRaU N9sjz7Sz/cfyBgv8rbNaPTuXCC+x1FR++6V6ovNO8gbhZ7/zdml/JG8wofZlCs/7nfISq156ITj6 LUfwP/htqu6jzNcLyysHT3DRfRt4fzZvMOo5MfF3ek+TvEGNH1zyBqk+yf1Q1V8e4Z+n5zXjJUbe IPgVH8bJeIn1++b5UricybMRvq0xTrwDEj0nSN6g1LwfE6fnBJcjeYNOeWaDRxwS3X+El3jmDaJO DH0Xs7xB5NmAnyh3dr7QvEHN75hxgPScZ3mDTfOIYljruBo5o8/Qlv2nZaWIHMkbvGvWQi9snbG8 wTv/Xfuj65PxCyM/B++qPb7gLWfzbLLqs2z8BUbO6sVpvnYELtrZeiF5g2LXBQ1AknuM9vfMLzz5 Suj7nfELB11nyKcs9Pz8xC+M/UDvFZI36MCHi3j9Tv18JG/QIz9c34GzjtEpR/IGx713zXtFvijd 7yRvUM+JcbDk53cHyxt0Os6qfg2X6Dht3mAtk9c2Pb9TSd6g8KWP/sDTHem8W37hDJ785nT/RXZP M37hmbebUe+FrheSNzj988jr4eegzRvsDjzISc+lTOfP3g8SvxTG+xF1fric2bdifwy+X/DN0Pct 5RfWfRs076xTu47kDdam6yzN84Xpk/ELe81TDGpPcL8N4xcecTpyjyFemN0rJG9wEOvJept5rez7 SN6g1M+UvHlZZ6Gz/W7xv6T9OiEwHOuF68XaZzPf0ClOUui78VPeYH3pfcv2H+EXFvyhaXzHrzs/ /JQzOFfziNcHv8YedzHlSN6g6tMLYe+vu+7qKVesHPAO8DXveTZTjuUNTp5ExIfQc5DkDRb0J19w 4pS3nNVLmHKJ5KtNOZI3qP/Ha7zjnW94yh16aRrP+kvNnuVdpYVFP9VnTtrvu85yIXKkLqn4sxJw Y03TecsF/DvCM6snToJfRJb3W27WQSX1byVe5s1vivwOyE2c0uKGsSBev6pc9S8qZ/PHMH9J3yvA fY2cyR9r2A8SR+gk/IbIGdzw3V9QHEjtAiNXDjlYwH7ygFTFb085gxumNPsDz6Xem0bu1EtSvMKr f+PGRY3ciY8Jr6XEM1RdL47On8ENNf7hWi+xxgUXNXLllJM6WYIX411M+zO4YZ15g0HvzcbHaXBD wdHEz6t+b8TPGzmjl1l3dcblyV8YOYMbtsmH69Wv0RxdnwY3DGDgvvHGQsd5nC9LPlfd8myMnI0X lvftyKdUXK3T9UnihYH/9bjag0bO4IbK2xTAf/fjA12fJF4Y+Ue6bi6zi47T4oYJOJ5XvgvP54HE CxfFc5zWGfGBzrvFDVPu6E95hvh5dtqDEfr30/58kLN5IVIPWPa78odkuh8I3yjqPtZZn4utM8Y3 Wl5vu+LmgzdyFjdsWl+0gY/TsfXCcEPxF0QhrpdxsnOX4IYVekV+HHiNTjnCN1oVD6+Iq3yQM/os AfpEPQ26XkjeoOYRRbnA3v5dI2f0In464dV8Lf4CI0dwrqx6KWve0ilHcMOi8xDBexfoPBDcsGp/ HvVs6D1G8gaz5nNp3aw7TsfIkbwl1SfqRgA/MnJWn0nxxphWXhUjZ/OWguLTM38z0vl7qmc64hPq 4j8zctb/iTyGPOuW0XEy3FDjI7Ou61bo/BHcsIM3dOb18P6sX7iCNxQ4s6PzwPzCco6/633S/ghu 2FQuznrJdF1b3BD2dZ083VyfrJ4p4vzB76bvdyN36DMh77Ne+zYu+K2RM/iY1le+Boq6gdR+obgh 8OIUFzzOyBl8LDvgK8ADCjtfPvCNtrjWNzRyFjdMOn8l+OfvY7gh8OKCOOPK5p3ghvp+r2KIfpAz 6yw63Q89fljXDDeM8rNPPIDe74Rv1AM3TMgvpucZq2ca1M/ucA5SO5nVM83AO9KHdU1wQw855IGh vpqRM7ih+hnarLfbEzuXGG4IPC4gLojanww3LFrX0qNufKJ6Oc/5rHUKhhzi4KmdZXDDEcALfznq +9L9TnDDNOv4AefKdD9Yv9SsJ1Xg13jR+bP3g9QLEd5QnC90HixuqH79Nut3gJ/WyJn7IUaNR0H9 HODTp5y9HxLimmfdY2q/ENxQ1ol8H/K8qV7sOV+w/2pZ+baNnPF/JvBcesQBVnp+EtwQPJB3nByV Y7gheBJbX3ASI0dwQ5WbvMR0/hhuCD97mH5Ttj4JbpgnbjH5P9k8ENxQ65Fe5xnqknr2fQw3RB1G H9f676ecxQ0DeLo7/Oz0HU5wQ+ElEr2+Fv/8KUf4Rh387IgPSfT7LG4Y6qwLrOc83Q+Mb7SrPlMs H+QsbqgtXXIe9UXperG4ofhrpD/EY7J7jPGNel1nTnkkCrVfGG7Ydd5TTs/7iNUlRbxGnXUA2Dlv cEOncfqCy6CuyYvJWdxwENFJfVHw71K7h9UlBS+xxvloXTgrR+qSdv3OClwt0f6e+EYd8kNmnVAj Z/WSwKMLnDJSfVrccOrTAben9jzhG504UE9rnfNTzuKG8n/6XQeucL1Y3HAMTHDVXBe8ysgZfQo+ PeIEUKeX2iEMN0R/kyeYr5du9OlQlzTBzqL3H+MbrRqPknAf0Xc44RuVOJ1w82N2ak8Q3FD4oRbe ULr/CG7Y/VzfmAc6TpsnNfHprnzbno/T2vMzbgb1MAv1S1ncECecE2JTuTfZura4YZp5fE7zhAu1 dy1u6MV/MswztbMQJ3fKNSPngMtM3IL650/csGndduX/BM8e2w8nbth+4FFDnaYhx/o7ccPRH3AS 8JyUzvRy4oaXXJ240+u14JSnnNXL3R/yKeUvTjmLG1ZtacSHKF5M7QmLG0bJ/xvmoJ5Lco3dcs94 sdSJH/Xn9OSRY/SS044WntKT5zLdfJwN+aKeyqVD7o67iPqeBo5n5JqRQ31Y8Blj/k45y//ZsR9m /q3iFkaunN8345AQF1Q1HuyUO+YvIT+4Ir/8ruNg5HZ9Fo0LkP6iykWqF4PjVdSj1XqoN4+1kTvx TcGxpd4d7M9A5QxvaNW6qXfeC/BwI3fim23WxyuTh7UzOcMb2iavZtZ7BXl8Rs7oRXlHxjjrcr4Y uVMvbeYbIj/nQc7whnqthxkESJV5p/Nn+d2EF6ALjfWYv9hofxbHq7rOGupWg7fXyBm/90hcl3NC +wt8H1leuDt+AvyYgc6D5YWrMUFO+vPq9z7lLC+c3AvCuxxVjp4vlheuRuUbjZrPDDzulLP8bqUq PubB1xXp953vdwf+Oq95gLcdYuQOvXhxfMn9HpSnlM+fxfG0rsllN3XVC18vFsfzqIs48YfG5sHi eMr3O+r7wu/d2fcRHM8LbuERFz3j8oycWWce9fEi4g7p9xEcb6vXer87TjmL44WKepGoc8DHyfg/ 8X2oO5fZ/NH8P6wz5dEFL5yRS2d/ittq4JLIsfOa8H9qHSqvcX1K30vkLP+n1m/wwBNmfqqRM3rp zaM/nQfP7odn/s9aZ/xSpHKW79fr/iuoqxfYvUL4P9Uu8HKhyDi5nNFnAv5e8uoHO+UsL5zUJxz8 fh15g1zOxlnJfI/8rLU+wiln87yVH7Pc8d583s9z/jJgxF+QtV6FE7obJteMnOB/Zb47gKudcuc5 nxTnF94u+LPoOM9zPgngt/Dz4b1yyh12+axvX+/69sXRcZI4D4nvyPP9Dj+7kTP6VD7covEld50t I2f0qby9ZfoVUUfslLP54epXqor/3nx5Rs7o04NfauYN0n1kcLykdVCED+ul/bH1YnC8JA9H5bVS 3CKx/WBwvIT6Y0XPQSdhMETuPOfjdSGoPuEvr/SdY3C89KMrfciB3432d7wDspirwv8569RXqs/z fhj4w+RVQZ1X3l865fQc1MDaISd/YeUsj1IEz1dY42ZOufN+yFpHUeoc6rw3Ok7LC9eBiwbcm/S+ NTjeOw8zKn7b6XlN+D8lTvySS+CJSvT7LI6XE3AZrLNM+zvP+YGjg19q4nFczuhFeXvrXY+v0XGa d0BGHVQP3lfUHTdyRp93fzPPm527BsfLwKvqfE83vq7P+2EYkhN/X+v/nXLn/TDiC9Af4lEqPV/s /ZCRN5/Bd0HtQVY3MKicg11A/RoGx2tSwEPWS0O+GtXLec438DN0ravwZBcYHK+h7nG7cZLO5Yod J/A/8BAk9n1J//Xb//kjMMzwb8A/kem7/8T/NB1d4mr1313TwuWcGadHnjDwP2pfG/xv0WeGnUW/ 77xXiuIWA5/W72ud3e8G/xvnLfJT88ojb+RMPEMFz8JH+8Xgf6MgEeoioh4Yvd8N/jd4GTL6w73C +zNxHhIvI3mAiJdi57zB/xCfM/oDv1Si+rRxHrkiD3PyxbJz4sT/5n17Td+Mz6L+F4P/FcTRNq07 93RvGvyvaV6V8KYB96V6Oe+Vrutk1oe9829PufNe6bALRp6b6rPRcZ73Std8M5FHXiudh/N+6Jpf On6m9Ekumf6q5lMGxBk7qpfzfhhEWNi3891I5c77of404JQeuCi1Pwn+VxAnUBzwfnZ+nvhfFpoh jfdvOM/o/jvvlY549q71Yp7sQVJvcM5frWt+qpGz6wxy8M8D1z7lbHzIjEPKiM+i/k+C/ymf+Ki/ qecS9RORvMGUEAcB3Jfetwb/G/E5cb/HmF5O/E/yaFVe+aVnvtMpd+J/I49riX/xQsdK5Ow7APky zamfNlM/34n/jXXWdJ11/0HuxP+qlBvXPBbF8Sr1oxDeUMFzutbdFHuJnUuEN1Rb8lonQcMUrBzh DZ08Zi6hPhebP8IbGoD/gcezULuA8IbOeoPNAxdl/dm8QZ0/72a8VKV+lBP/G+F8kAsN8SgvImfx P/nPkR+HunOy/ayc0UsCjqf5kTe/G+RmHh+pUyF5S1n5tt55PZCL+HcW/4M+NcDx111Xz8ilU27G 6dQE3DBRuRP/u+VE0zeeesoZ/C/PunrIT63bPfaWO/G/LPUQvZv1bKqj32fq/+WJUyIP5Ulu10sX +jKxX3RfzHxKI3fmnXnFYVHnaeTH0f5MPp6bPKyoN1897c/k47nJj5k79kNnciYfz6ElIXQw++gt t+ulaXyijFP9LzsO+5Y79SJql/48cGYqZ/LxXJ845dzvdD8QHG/Yuxp+OOYvKv5+yj3m4wnO8euu u2rkjN9b+NLuOnnXc4fOn8XxpA7KwB/AW5GoXiyOp/ydSmzzS8WJnMXxlBd8DFD04gtdnwzHU9xi 4lyxMTmL41Xk/+k7/sfzebB1mlpQHEHrOTx9n8XxtF6103wSL+HiRM7ieMqDFX7AQ4e6zkbO4ngN +X/AZSKbd5aPp+tM803vfDwjZ3E8D15U4GN0HzEcL6lcmfXKmT4Zjud1vdQAOfp9FsfzVXEnqeN3 4kBvOavPAnzMIV6Rylkcz2P+PfDGRr+P4HhJ80yz8nz1zOad4XjTfika10zPQYbjRa1XN+M46bnL cDzs91n/3dNxmne41OHe8qToOG0dv444AckHuvmejJzV56zfmNWep/cYycfTvGKP+grHe/OWszhe Fpwx3fU36TlhcLyMvJeiuPHp977lrJ9WV/rId1vzUIxcOuWUj/OSA38dPT8Njjfq2aDOFvLV6Hlt cLzxfSpXtnqYRo7oRevOVZyD1O5hPJ7A8ZC3C15iI0f0GfF9/sP3WRxP40mK+rFP//VbzuBVEflj iF9q/Py0OJ7mvdSb92Cz599yFsfr2p9D3mBkcgTHUz6cGx9rmZ0TBMfTvImi/pQhx/RCcDx5FwmO 5z/0d57zQ586Dy0Al2HzTnC8jDpbZdZNYvvoKR8vS1nu5/ud4HiuqB9z/M9fd30SI5e4XP2JyM8J VJ8Wx+vAuVDnvNPz2uB4BXbZ1R/itgP9PoLjgQ935nfQdW1wvPf3pbrmzRs5qxfsowC/VOD9kbxP 9e961N/M7JwnOF4J6tfH+6FRu4DgeCU3zMPL4gi3nM3Hg/8lzHpEjc6DvR9y1nnIeP81ds4THK8A h0Wc8Y7jveVsfnHWdVaQp9ionL0fCnC85gmO95azuGgH/pfW/NtTzubj9Yw6acA7NH/MyB16aZfd qfkyOD+5XU5wPOHV91roXuxPOn8Wx9N3XNd9ccblveUMjle9+iP3elmHHMvHyy/1KyLOKjF9Ejyu BuW985PXnc0fweMyzkHUJ+mdyxl9Kv91u/EO6l+i+Xgqh/qpnfqzDB7XJBBWeeXUz07fDwaPa8oH LvqBXug4z3N+9Ae+7Rkfwubd4HHtzodts54bW58Gj7vkuq7PBv5Buo8MHteEIE++D3wsla1rlo8X dZ1V/b5C3zkGjxv4LXDD+X3s/iN4nNYBaHd+6oOcwUkyeJB7IbjMLWfxuJxVLoKvkvrdCB6nfAlv /I/e0wSPk7gQyTtEf3QfWTxO69RrgPnj+4jhcchvDMDHPNXnec6P70N/4InierF4nL77Jk729H02 H6/qeSZ29a+7LpuRM/qUuLrJq/p4npF8vKznde31w/eRfLwEvAp5itTuYTyeyIMu7sP7neXjNegT vFuBjZPgcQ38rcp//vAupjyewA1jep4/hsdVPV86cF96LhE8TuIERj6sfLm4+4gcycdTXK0jT6rQ dzHJx3N6nt11cOh5duJxTdKHXpJ/pOdgo3gHweMy8i0i8lAKGyer4/dSua73Xwls/ggeFzHO1j7g OR/wuKrx0HvcxZQjeNzMiywZ9bnY9xE8TutbuMkzVB37PlbHr83+4nN/BI8Te+ldl4bbBRaPe+NV leQRJfw7i6tFB7kck52Ht1wycjN/jOUtveVMXp2HXlAH4KE/m1fnZz5eQz6ep3InrgYezyGn+2iz z245g6vhZe703n0cp+W5rIqLlts+4/2deWB4gfoZX1c3P8otZ/Lj5Jko/sWOeUhU7syPmxbbrFe+ 5zfeciY/Ls18NVfQX6dyp16QFxm0Ps3jejH5cfOFNutslUbHafLj0uS5RBzEnjf4ljP+eeGBH/QM ik+HSsdpcbWs+SStsPy4t5zx6zuPvBfFj1yk83faWf6n4xwME7+l68Xiak7et27ef97RfWRxNYd9 1KvmA2249lvO4h0Jcgn90fVicTXF09ShIXJULxZX03gudQg/j9PiasITO/LYNa/HBzrO01665MR+ CerndQKbMDmDd2g9DK+86W7WwzzkCK4mfkEtX6x+aDZ/BlfzP/N86Q7xg1zOrLNbDvGYmZ1nBldD vMzESW7+iVPufE9fch1y4Oej+4jkx+UEXAbxyXTfEp5LP+uSIp85s3VGcDXl4Qkz/2H3L73ljF6C D/jOl30H3HIWV5M6psLznOy78S1n11mEfiDX2D1GcLUAXK1N/JauT4uraT6Q17oM57v/LWf0OXkW UE9qx2XeckSfiuNl4E58nJbnUt85US7C5/1w3g9ReTV81vomp3/wlrPnvNQN92ny2u54zlvOnGea j5em/dn4vNtzXt9/Sd8tp5/2lrPnvOKiacZj7jjCW86c8x11H/PkaaP7z+JqMjNjnW08l0bO6lNw maT11R/Hae8H5WvOmkfmBL5nckaf2Ws+Xld8pfLvIzzITvMGI/JsPN1/pH5qUJwyw39N72mDqwXw XytgafC/t5zVi7z3LznwTnq2jwyuFrQexpAD/uDZuja42uTfzULQ8evmITdyBlfTfPSseddP65rg anJyXGJp1h2gejnvh5H/pzge+EMaPZcMrpYkUE5wX8XRG7V3Da426xvkO0+RvjsMrjbzKUd+Xfgk Z/Fb5N8WxIc4Knee8wlxAnnW0Wz0/UDy45Q3K2ve74nnvOUOvUTkcxXNA9TyUETOxk+kMvNF9f3O x2nP+ZQj9jvyPun8WVwtqn8whFlXlp0vBleL2EdF63Sdea1vuWTkqn6fU3twxw3fckafau8WrXP4 dA4aXC3Kw0j5nnVd0/eKwdWibMCbn/jM973lSH28NNcL4nSoXkgd1KQ/64yb4f1ZXNvpPGTktRb6 fZbPuCNPWCypJzvE4GoZ/AVVCOh+nXEzUy7pv17uTd/VT9Tg5yvUfiF4nNh1XeNMjV/xLWfnAfmN Drxpka0Xg8dledioHHiz2fwZPC6DV6XoPXjm491ylj/ZI+8T/hBuhxg8LuPdV3WdOn3HW7nzfsjI 865aV+HJHjR4XNb8S6kzCnuQjtPGXWh90aLr5un+M3hcwvyVnzbzp+n32bgLjdcoE/9r1O/G6urp OivTH0LfjQaPy6gTWiSw5/EeM3hc0Xef1HXGenlROZOH2ZDX6vNaN/6Us/zJUpfSK4HIrzNO7i1X jBzqCd95inTeLQ+y5JGM9an7lr+LDR5XtK7ekEN9BHqeGTxu6kUdrwb3veUsD7LGUdeJI+x5im85 ew7KOmuKNz7uI4vHZV1nDfUmSqL9sXsFdQdgv/Dz094rEbz1IWI/0PVi75WKOq/znq50XZN7BedE w/thiyt5yxl9tqrrDPl//Bw0eFwWYgzl1399kjPnWS1znOC/Zvef4ccc+w7xPRlx1GzeTzxu6DFj /sAvTM9PgsfNOIGO+y+xc5DV1UMcy/SH0HvT4nGy/JUPEPGYbH0SPC7Bfx2Rr+ZpfwZ3Sh15bh34 GLXrCB43+RWLTxavuuUs7uTgX4LfrVB7kOBxUy9J4zxqYPuB4XGQi2pHVnpeMzyuoL+OfCD2fQSP a+oHm3nenc67xePizJNy4Lvf3o0F/47xvo59dP1Uv9bE37P+/czHEyfCIpdQ76z+qKWh9MZWLr92 uaBxm8KzgLhm+YspN/P4GE8U4qh7WOvn5KUfJgd/6ZCHn0j9rXnXi90P/carAvDpdZx3+7aOX4Jf Mar9UjV/xcilU65h/pLqBXX1jJzBq2Ydv4T3ZqTjNHX80qz7eMvR/kgdv5mfmj+N09TxCw37NkbU //NUbtdLF/PxpXyA8JsWKnfmx1Xl907XRswLbnHK2Tp+GgcdlEfESboVkzvzBtWfKPiT3puOjpPU 8cM68wF+qUrlTr3UyRsaFBeFf8LIGb0UnPPgXa6d9mfyBquen0MuLX4NI2f9Gph3rZs8eSBPOYtv VvAyIm8CdfyMnPVrOK2r1zvwTTp/1q+hcWtB38UDj+Nyxq+hcZxe6wPf8fOnHKvjpzgeeN3Bd2jk iD51nF7zgVDH75Rjdfwmbqjf5+l+sHX85r2i+VITvzVy1k/bFGeuiJcqdH0S/3VGfTzwHjg679Z/ LXXcLjnkte73w33/WHxTbuCqPHKyztg8sDp+RevODYBExsnmgdXx6xHfh/wApk+SN1hS2OVof6SO X1J9VuiFrjOSNxg75FA/wLH9QPIGE+bP4b2Z2X6ndfy0rl6Dv66x85PU8QtN684l4MWerTNWxy+h Ht/kGaLrhdTxayoXUIdR63Cccoc9MfIGNV6jTv9Zpd9H6vh51WeceSEvKmf1iXqDiOfr1C4geYNa t+XSS1/5604565/wyNOYfo1E1wup4yf3UZv3dKPnPK3jh3wg8I16Og/WP+Gc+t1KWOtvGjnjn3B4 b0bUywp0H1n/hOId9a5nE2l/tk6TR925OOPyqNxz3uC9zuh+IHX8EurxNeRv0nk474esvHUSt4/8 I7qurX8iIy4WdXeAd5xyrI6f6qV1rBeqF1LHz6tf6o6fYOua1fGLqN+YV7+GkTN6yRV5S7U/n2es jt/kA4Q/srLvI3X8HPwodeqTyx16qchjb2JQPt4rLG/Qy88OPuNO7VZSx0/5HLokor9xPCOXzDi7 8pGFySfH9jur4xc0nwR1zvk+YnX84KdF/CDqUBk5o0/XZ129+GGcrI4f+BXBg/UgZ84ziUeQcfrn +93gmwVxJV3tAycwLpEjdfwQ5y8r4mm/kzp+GTyCKcOPyc4lljcI/xL4hXPmcuY80/pxbfIoPfVn 9KkaXur4cTmjzymXkMfX6flC6vihvlou/UN/1n9dce6mtOZ9nnK2TlPx87xGnQO631kdP82XQT1T 5PEZOZt/FMEjqO8/R/0FpI6fvhtRJ+/OqzNyJi9k5gMlrZ/TO7vHnvIGpR6KxgtTe5fU8dP4lw58 e/LsGTmjz8n/qfGxM0/KyBn/tfLc94njgSfxlDvvhw5+hn6f8/T+Y3X8xn17rZsYV9zplLN1/Bz4 HGHXdWrvkjp+Hnk9CfYn3Q+kjl/IM79K7Sx637I6fgn1+JD/19j9wOr4JYxz5rXSdWZxSo0THv6s 1V9u5EzeoPrn+41P0/v9xCmlDhjmb/Kj0HXN6vhV+TnjhandQ+r43fmG4NWk7w5Wx6+j/ljTfUT9 g6yO38DVpK4e8Bw6TlLHb6wTkUNdPTp/to6fxLUOuYK6EXS/2zp+gmuPenDgIeh0nDZvUPhfgpt4 XKfnPMsbRPx81TjxzPuzeYMS9xL8XceB2gUsb3DmG+K8pvfDiVMOOa/6RH3fh31L8gYr6vhlnC9U LyRvMGm/adbVY3Ikb3BsAK3Hh/7YuUTyBsdRrON86b5l68zkDUYBcLRuoPJ80XlneI6M0/+Az8M1 tj4JTpmRX+XxbqTn0hNOKfX4/ILHHXIWp+zttuvUD03PXVvPbe7I6z2Nule0v3bKec0bDFrf+Y4P OeRIHb+M+niIhy7UnrB1/PzEU5PGC5fM9gOr4we9FPV7698YOaOXdz2+WUeMnZ+sjl9QubrlRR5y J045caAuYenP/penOn7Cf6bj1PemAnFL3bJdLmle6cAbI9anvscOufLa5YLGfw154GrFrXITbyT8 n3nmH03+zxeVS6fctCNvXkZP5c48xZvHs6ufD3lnp5zl/7zPeZUD/6eRO/MUs64EN+cdPJ6nnKnj 1z3OiRLAT0v1Yvk/Zd6apL3IuVSpXgyOp7yaXeuK/rrznU45y/+JFTv55xFfYOROHM9NHK/gXAp0 nJb/M0EuAzd8kDtx337XGwRerHiHkTN6medLRlyCp99n8hQdLC+tf3znMxs5m28xeDWWOn6d9kdw vNdLcbwZN0q/j/B/+oT7SOzWoO9+I2f83hW8jCECj+Nyxu/dcA7e/J9UL4T/M2h+VciKb0b6fYT/ E3yOTnkWfKbrhfF/6jjBC+AzPc9IHT/cD66u7xUjZ/KdOvLVPOoNVipH+D+L1nNLyjvp+bwT/k+v +Obkt9F49kOO4HhyY1Sha15wPCNH+D/1Oxve74HNO+X/1J93HT82fwTH8x35t6ijktj6ZHX8Euqy ga8ys/Oa5imCpxTx0J3dDwzHk/Fp4pGsM7bfGf9n1LqP8x3H54/wfzbF0ZF/6+h5zfg/wW864/U9 nT+L4znw4XbwonI5i+PJ+bfyMtJ5IHX8mp4Tk1cl0Hkn/J8FPJ59zUcwckafefJ/Ik+40nmw+Ss9 abxULfAz0HES/k/kZaXJT0TH+cz/OeuBcb0w/k/tr+OdSu8xxv+J/qZ/PlK9MP5P8GqqXY78TSNH 9AL+z/hJ7rDL04++KBSuknXG16eN81Ce36x8uE7K1jG5Q58J+cxV41yd1kEiciZ/TPL3Rn4AcHs+ D6SOn594sY4zsPuB8H9qHdSBz+g4I9Mn4f/UOIEigbsyTnYOUv5PzT+qwKepXcD4P4Pm9TTkaaTM 5GwdP/V/DjnNO2tsP5A8ReU7KPP90BodJ8HxspxrddbX7rQ/wv8ZEOcPvrVAv4/wfwbF32sJS1yJ kSN5UqgbOHFKdj+wOn5N4wTu/A46zvN+WL+vffg+wv8JudRRl5SdgyRPsSNOIE/eV7b/CP+n5F+O +Hmss0blCP9nVB4614Cj03kn/J+YvzlOak885SkOmFPfHcDDjZzl/0RcQpp4Me/P4u8N6wz8wvT+ I/yfFTyz8L80vh9IHT/Eh5RZb5CeS7aOn9QXkXqDwO3p/Nk6fn7Ww4zgrXhRuUMv4DmUPIiV/8XI GdypoI5YR31Kvs4s/2cDz2WavH7snGf8n7OOX13jyA45huONkXet0/Prrjdh5Aj/p+IP4Cfi9jzh /6xuypUFjzNyBi/W+mM3rybw4lPO5qGoXY78saFPqhfL/yl8AGMegR9Ru5zxfzbFbzv4PArbt4z/ M4NXE379yvYt4f8MqLPlJo8L1Sfh/yyIY2kr/6eRs3px4BudOCUdp8XxxG/aftTT7CTNjsnZ+BcH vYBvxrF7hfF/BuDok4+F92fxd+gzAK/ydN4J/2fSnwX1ruk5SPk/tb8InmBqtxL+zzbxW/UvOXpv Ev5P/fcd9ctmfXsjZ/SieRod7/gnvZzn/Kh/OnlD8T7icrteBOcCP+bMO6PzR3C8KueZIhNOyrIz OcL/Cbx/fh+dBxvnMeXUrnh4b1L+z6V+451HdMpZHK8hHkx5xSc+beTMOtP8v2W9sHlnOB7il1L/ MA+kHl8Dr23GO5W+4xj/Z8S9qXV+HH0XE/7PDr1U5YXzdD8QHK+Dx9M3rBc6TmufzTxF1Dnnfn1S j09O4q48leMcpPeDza+quKcd7mnEL51yNq/OwY951+Nj/ZF8Q93vbvJyFHqekXzDiY9F8DLS7yP5 hsKXNuv8nHjVLUfyMG/e0PiMB9h6fD2ANzQ65DuxfWTzDWddvQi+2EZxJ8L/mXTepb6rvMNXuWfe 1zJ5/ZJb88AgN/MbSR0/6Sdf06Dnmd/suinHeHTDjA/Rc6Ku51J5kJP4TditM55hlXv71YU18JaL WevJRq98EHf9Mf0Hb3wz79+XpEyv6Ccjn1LtiUOuvna5AD6OpO8GifPwi5y/x2nwTbUwNID6vR+M nME3lf9TEzd/3XXnjNyJbxaP9dnbysN6yll8866nWNf6hkZuvx+UPkLHiTgBPc9OOYJvAoctymuE 89PIGXwT9Q1xcyiOSOQMjodzt6CeBvJQTjmCb846fjgnPJ0/i2/C0pMC57/u+oanHME3K+SAFz/I GXyzAqcsyLtWv76RO/NaXQR/65w/9dOecvlcLzeemjvqktJ5IPjm8C809RP8GumtdJzHOfiuB/bm YaXjtPhmAf+nnjNCZ8bkDO7UwN8asuIyfL0QfDMrfqRxoEKDQOQsvllRfyw15CnSdcbwTcVXxgKX /ug8nHYr4i2GHPiQOpcj+CbqN874ZHq+EHxzvIu6bHeZh0T1QvBNnEvJIa+V6oXhm1F+RodxMjmL bybhv67yTF3iUYycxTeBG87468DOM4Zvxopx6jw0ds6z+obIh61O45oTmz/Cw1oghzpbvbP9R/DN kVgqcvDT0nVN8E2tm+SQd6H1I4kcwTfnutZzvrL9x/BN1PtseOc4qk+Cb3bUfZz1Ldi6ZvUNESfQ UW/C0Xmw+CZ4pWtRv1Sp7Dxj+KbXc6Ii75reDwTfnPh0y6i/QufB4psFP1tui7/nlCP4ZtU8U30H Xnqh64Xgm+AtTIjD5f0xfHPyOSJvkM7fU33DrOO98ymNHME3wbOnPCCd3psM3yz6s1T43bhcOfVZ ysQbNQ+lUL1YfFMs4FGeC/YuX9cW31S+tSwP1V933pKRs/gm8L+g8SFyfBI5g+NF4H9d6ybBP3/K EXwTOJBH/l+geiH1DZviHU79pqhveMix+oYygjLjFRs9dxm+WRU3RJwccCcjZ3gPwqyn2MBPy9YL wTdD03qKTee9NnZOMHwTfIew6/j8PeObueHdSO1Bim8qHjfff/TepPUNVQ5xleA3NXIW38zoD/n2 1M5i9Q3DzIcFHsfuFVbfsM3vawueespZHlaN6xkER2tdSyNn1llEPmwEPzTdDwzfLMDxelrwv1OO 4JtZ/foOfKP0PGP45vy++qk/gm9G+RmUKWn6k42cxTfL7A+8B1SfpL5hUTy8oS4itUNYfUPwu2Wc n43Ow3k/pB+tp1Hl4S7nC12fBN+MmD+MM9L+CL5ZUB8W9Z3ou5HWN1S/jUe8VKB6sfhmDYo3Ou8X f88pZ/HN0hVXQ12hTu1yhm8CfwB/eafvTYJvyr3Z9V37xjeNnMU3M3CLmb/CzgmDbxYpqK78DIp3 OLauCb6pcbRNHvyy/9g5yOob4lzqBfgR1Qurb6h+duTpA7895Vh9Q8wf4iPpOUHwzenX/2h/UnxT ccq+1ak45Qi+CfwW+VzIrzJyJo5F+hlyyS944yln8M0k+UNNYGq5pxNdLzb+ReOQ3nUf5S+snNWn m3nQyPel30fwTa84SVQ/inN0PzB8U+vA1ZlHy+UM7pSAU0a3xqmechbfzDNfdPJK03kg+CbyKX3R d1yg+jzP+YFTKh7nwRdE/ZgG36yaPyT1FFFnme4Hgm8C9w3A/6hfiuCb8n8GX1vFecbuFYpvKv4n 8XVP72mGb3aV64ijpvYZwTcbzs+MOHFqn7E8ReQzz3w8T+eB5SnO/oDbM30afLPd9Q0L+LPoufsB 35z+l8zmneCbueh9q/eE0F8QOYvLFMxDBS5K7dbn+oZ18kfSdc3wTcWrpM7Er7su8CFH8M0G/vL5 XqHnNcM300vzHPX8RB2HU87gm9WDL6+oXKF+RYJvjv9Wv5TiORqHdMoRHG/mYap9Bl73Q87im8UB F60edRHZ+jzxzaLx3ZqvhnlgejnxTS3/LnLjif5Ly/JZOYJvFp0H9SA93X8M31RcRvar2K3rfpi4 qMUDXFE8IN/+s3Ue8pSzeFwA7lTVntC/sXI231D/vwDTv+56kUbO5BuWMOcBuIxnchaP68hvbAV1 9TqVK6dcnd9XkY8XmZzF4+66jzOeIVC5E4/zwuvWtU6duR/ecjavLum6brrOaqF6sXjcrBsIO6t6 Ok6Cx0GugBfV0/kjeBzwP9S1rJtd8JY79eIm/yf8fMi/NXI2DxN4XAVu76leLB6HnTzrtiCv3MhZ /Gj4Qfrk/5HydUTO4nFiR1TlJfp15xsaOZtXF9XPrjiS0L0xOZtv2NR/7cEbmnh/JN9Q8Q5fFcdL 9PtIviHwB/WDSloKk7P6nLhagxxdL5/yDRX/y3QfETzONfSXLc71ljN6ET6IrvxzA5fxdJwMjyu4 x9SeKHT/MTxOv68i74yuT5ZvGLHOYLcWLmfxOOCwHXGAnumT4HEzf0ztc6E7YXKP+YbNr3y4p5zN N/Soi1jAj0LXp8HjnPJyDH3iXRXZ+iR43H3OF91Hkfb3lG/osX8Pf8FbzuJxmPfmgY9ROYLHoS5i beFDfyTf0Kte9Dw87PlbzuJxkuddJfxF7Qm2j0hdxB4rfuq8y19YObvOMH+tQp90nZF8w7nOYGdV uq6tn1bzppMEIMn6pPokeFxHfTzUB6LnIMPjvOIILq08pUbO+FsVV8vyYb/uuF8jZ/E45CkiDnB/ j91yLN9Qv68iLoieZyzfEHppbo1TPeWMfR2i3ptv3lB2/1E8DvXjGB73lrN4AHC1qPkIrVJ9snxD xZ064g4T1SfB47L6oV3GOOn6JHhcRx0j1CPS/MZDjuUbduT/gQ+e2gUMjwNOOevcZbbfWb6hh1z+ 1B/B4zLwuI2Hx8gZv2JFnbuO/IBG+yN4XJH1NuNtwD9o5AgeB5ykIK+OrTODx2X4iepPUHsQ+cVG zuJxEx9D/hG1kxkelxWXufmh6XoheNzExwryDakcyTdEfxPHC1QvFo+bfvaI+jkPckYvGfh092t+ 8SlH8LgweUpVrtB5sOd8Rd4n+ABbp+uT4HHji7vaj79uPh0j98j3mzQ/vHV2LjE8DrzENa71iIyc xePkZxVAx+B/t5y9Hwr2A/wvD/0RPC4gT7ERPO6WO8955H/JelF7ie93i8eVpniHrrdrG9NxPuFx TeuPPdlLDI+r6i934AWo9PssHid5m77f75XK+rN4nCJf/ZqOGf/J5o/gcaWrf9f79DxOkm+Yi+Ik WGe9s/ud4HER+w/+3Ubvd4LHReQphqDvFWonMzzO67yXkD98n8XjfAVepfZEp+8qgsdF4P2IQ3qY P4vHRa910hBf0Kl9zfC4pD/BA/IkZ/UCPA55g+BhPeVIviHyetz0X9PvI3hcwffB/qR+MIPHdXFI 6r7Xead2Hc03VLxjzzc85QgehzxaiZd6lrN5YCFDDvgY1YvF44SHWnA15J3R/WDxuAK+Xz/PM2Z/ snxD4Ct+vhupPhkeBxyvfbALGG8ocLwMfxaXI/mGem/WBPyB2p8Ej5v5eHNd03ua8YYGyLsP/hCG x838uBfuB/p9LN8QeYPBP98rBI9rwFNz+vDuJ/mGbcZ5pPz8fQyPA/5385Sy7zN4nNc8C+F7Vj9f ZOcLw+OKx34CHke/z9rzBesF77E9z+aWe8w3vOPZ6Xua1DdsMz8Hdqtn+4/gcRqXNXhfFSeh736S bzjzbJzyXZTA5o/gcS/018H/2dg4CR6n4xzzofhKYv2RfMOJ4xV9/xXqryP5hvHON6zP+NEHPC5q fGSm9qfF40rQfMOEuN/uqBzJw0S+RUioV7d+38zjI/l4g2hk5ON18PNt53V9kAtJHjbjZ6xtOT8l 0O6yna5b0Zfr6ZvKP/zpf9Cvv/39X//6j3/++//yl//7L//28/d/+/u/Rx/u+lVKGj+v+9WtP8ff xFzzn/z1UnKlluDKn65brYb6p5f79xjM+eu//O3vf/7X1+tPf/3nP/+nT//ud3///9Bf//B//OVv /+Wf/v631//+z//6v72wGv7hz//0n//jX/0v+XEdBP/0l796+f367//rz//2H/7xP10q+/VXWeR/ /ct/lZ///E//5/zz/zr++x/UV/xOVtXNcWwR/XPyl4FRhmE2A0rhmPmyDZENGuSUumRfvZ0DX7Yx DKM0AJLxE4Gfd8Hj79qQZ0GImnQW8l20R8Htr9oI+ndNIjaEQB0OvPoH2pAiTGmAdXkYkdrWTSL1 VRtwuTUlmAzuXUj9e52qeRA1C/lXTD9uBkN//y3trY8m46gzQL193UYXsz12YRm4jNwfD7KA+L0+ 9KKKXTIbRKceRG75QxtyWdi1LkkS11pvILVRo/OhDXGU2TakwN01jkmUqIEXtA1bzrapsTbwAina q8HYIN/+qg2s0y6Z8FKQAAHP6XluTRuyTodOhxM4abTRr5v86Ks2sE7x4At+EkB+Wh9nG7pOQxPW nrFeA5wp+ftvudepEMwF9YDLvDy30c/npM6tWrFjfQQffrdf+vk0udsYa/xqIyXsW7pO4cg44V5Z H04fGyFMEkEE4X7XhnzbZfiMCq/jJwiYAYx/14Z82yUrZAjXOoXxhcf5V23c56kGMF8Pb5cWh9B3 bcg6lf6r/PQothPpfqFt3OepDyCqiSAq/b4NrNPrHE26byU46Q6S/aoNPGm6nj3XfkkI0A10v9A2 7rUe4PwICJZP37ehpvldQCVMAs8e6Tmm0ibcRtYpkovHOYZk6PKhDRPygbUuQE2IM/AKBbRoGycc dbcx/peMo7UP9gdt416nIU2irbYAxN+1oevUCQvIGAeKESE556s23uu0owAPHH78bqBtYJ06qUor 48gAXZ7n5Wzjvcbg0JsJ5Ol5HOdz/Z4XIXMbxVDGY+wuhkjbOJ+MdxtSEHgURkGBbW6PleX3ow1x gqpzGU6Ozs912sZ931YUOCpIxHf0XOdtOCQBaJGBro/u2xn/VRv3+lCi0QFAwPFJ54W2AbdRv0ns OkjMuQ1D21ju2+mYRsL467GN9Hqal6ggQ/NrUv1XbdzzkifRpFOHoHvWh2ljzktscCb3P/wt73mZ CUUF64OeQbSN97yESdJZ/ui3vOcFxLCzcLdncwsr6jiT9f+Oe268G0KZ7zn+fsG/PqCcuw0h5A9F CyHdgWS8DW4nDy9flHtmkm/Ttf7Qhtow447yMh4UvocD/qs27rtBSSa7kmk+2doPbejdgIKWodwJ g/2DTs82RMfXGShJiiG/i6j+gTbmvEggdngTDKQ/oA9x3oYR5FDEbnd+Jaf/qo33PRdRkAvnevt+ bjW8JFQNAgztZxaX6cx3wdvAXVkU2Ll+ItERgTBftXHvOY/10bDGPq3Ts4QaWhZkcIwjxrUwJG3j DK+523Ci0yLRrfKOYmeQ/uvnOzvM+/al8/J8fpxt3PslzaKMsB3yH2hj7hcBaMNIqNd5Kc/6ONu4 11hEsc3prE7fj+NeH3McAQU06fuFt3Gvj3m/VJBX0LNQR/1g4wYlsBj2kAKsnvrpeBvvt5hXfXQk vdJ3w0Mb8y2Wgxaocxpw7T2zg3gb770P27JN8gK2TnkbmJfL1kcByJqVoMqzfcvbWGxc2Px4E1Kb X6Uhc9owXRAtBSSRUPo8jrON24aJTteH6x/u7Ic2pg3TYFtmBET777/lbcN02JZyzk2Q9Ks2bhtm BuKk0v/ot9zzMknHpw1Dbe20/E5tS9zZfU0o/6qNAM3+5FreP+8g7O/auOfFwU83Cca/H8c9LxMs Tx1BNWyN8TbuefGwk0tdCai/auNtWyJIIMHnSO/9CU4/+LamL8c52JZMH7yNe79IkPTQaYa/kJ2F D23oOTb2SRGfo+/5j37LPS8V91yHzzGy/cLbuO8XSRgMOEee/Mm8jbeP3oMsGqQE6VkfZ8jP7YMd mWtDHwnj+NTGET6CNq5zbARvRXcXcS7PbRjK1ukbj/DlZKx1+o7ibSz2Ot51IMNK7Px4aEN941qR T9aHWwuLfdXGYn/AZ4BxxO+/Refpmpck+ugzoZjbQQ9tyDyNbxh4lMwLyFGe1+nZBrCkJJHeYxwV hJD0rnxoQ8LTYviZP8O8K/9AG1Ut3x833lERBU+f7lvextseiwF3VP3dWs9HaN2NrY0YIyEKnvY6 O0/RRqVvj654x/gWFOuiawxWJfePZclcFV+fElmiMOdXbbyxpKb3fmtrEbbv2tDzFIkyY9+CSIDe UbyNxYeCex/kDvRu4G1Ap1kLIMs46h8dx/ue87O4R/ydPh7eUVELDAwieBCGZLbWeRvvcyyrvX4X jWfn2EMb016XAOzr/eBgS1EfPW/jnpeA4McA30Vi5xhv422vO8XVNQHv0sf33/K2170GuUUE1VGf dFtlrL3uZgB2XQP6vmrjtgsdbMuekXzI9PHQxrQLJUFI3sj9j47jxl4Vo24gGX2wk3kbt10YCgrE pDVw96s2zH4pCKrd3qZh1x6flyYZOvKzwj9Wv27jnpdRNUjs9emj/34c73mJutYn9rrht5/beNvr KJ7TY7C+vs9tvO11JBjEqY/X122831F9/tS5fa1tpH0G6LwMv5RX/2lBwvN2739u422vOz3XZzD6 dmf/pg09x0bsSJHxZKyxEr9u4x2rkNVed1txlK/awDlWf2JXH6wQKYxxfN9Gu/WRPdb6asMom8lv 46XGn3NWAuMclKjLCzT9fRsDP85V35M5STStnMmvP9DGOHuyRsqONrQA+tVG+roNjcO4ZEd12l/Z /UTcDZrc8l0b4ufPUWOLrp8OeJRiJw9tsPigoYfh08ojubX9fl5YfNDQw8AJr3lJCDxNzzrlcSgy jiptRCQ3qJ+ft0HjUHIQZpfRVgPhcaHj+BSHkrSo0/VGbbCTA52XT3EoWfsfflwkNKc/0EbHG9mN /kO9ScITXWMf4i5GIZ+ifsuEmKtM98unmImgPrbrmyLeyK8POuUxE/maCPVvd/hQygd98JiJhDN5 ZHuExa9N23iwT5MWEgzKPPWbb3nA5pP6CYNW53nHOh1tfMQauzD8jvdUQ+JXZt/yCWsc79rhSxpv Q2BadG4/4oRFE8hkja0JG1+1AXyuarxlALngbZ9+18bUh8TiRT8LZvK1/gmfG8Hyw58d/e2T9t+P Q7GlOAgk9G2aYSfTs/ATphWdvufkzf56XusfMS34PMd4sE7lX5xtfPJtReC3sd5F4j1bH598W1cb adhhafiD1hhF2gb35cSsySQx/eg6vu5KttY/+nIuO2gkuF4/Ewj3O5vbj76cpqQUQy9lfe9/14b4 Q5ITcEBie4N+i2dz+9GX05WEJXYlT77fL7wN7ocZhUm9jAfxyXzPffLDxCZsauNn1+LZsLXRxiSZ g7fAvchZuBBFNsRKuvp1G7edXEBOCjJ3vBu+a2PGoAluO+47161OP7dx28la/KWjKO70w3zVxh2D Jv6x62eYBJjft3HbybOoa4EfZvuWsLfxYvMy3uooGNi3uJyv2rjnpTsk11XYluX7Nua8CBGXEG4m q4/PbdzzImQk8216x2191cY9L6PSkbyV8X7Z7obPbdzzonaQkwG84y7QxpHMRXM1rjtBCMJHDIee QX57e3xu4/aPSVGVYdMh70TjC79rQ+blekdF1c61xvQtVv3Xbei8BJAnBZCleXmCfNsGbh2vdnIc vi1tY7srP7dxv/dHVp2MA0UktnNsb+Mh5qopEcaId8Db48O8POYmRKyPOPG5Z53yeKnxrhy21PV+ SX71n37Vxr1fJPlv5FuA3N1/Pw7cDV0CTuWOQsy3e15jD/FBXeMMJLamLTZMgOxs4/M55qOeI24S H5ev23ifY5N0GXvffT+Od4yzh48t1eX8+KqNe146fJ9l831+1cb7HGsYR45/tI33/YJY64YiPX1t Y56FGDW998can/5C+C6UIOWrNt77BXhlAP6i5/p3bcx5kff+GM9L16liSV+1cc9LmqTjZY0h+aqN e14q4voi8k40LuerNu55iTO/YZL7reNIexvH3L5zaARvuOyPuL6BvmrjnpecdG4jSBv96/s2dF68 ML3ee/9cp5/buOelAEcOPdq5/dwG5sVrQVPxkSe7Tj+3cc9LwTpNM8aIjeNj/EdV4j55Z6utXfvX bdzzEgqKws68Eza3n+I/YtMCjLHreXrHW37Vxjv+Y8QGjDUGX476x75q4357yN0Uu77r7jiUr9p4 3/vADJpfcULaxkPcRVNClOFnx30bn+flQ9zFJC0BeRpb6x/jLgbBWJWffhaub1+38Z4X4Puz2FT+ fhzLvOjPiDyt/r0+3nEGfeojLX46tHGTFqrVgNk45qUIU5D4CxEDrzbdV23c8yJ+hzU3oXzfxh0P M+z0EUuCQobh+2954/szzqD+4XHccReSfztyRRHvEOLXbdznmLxb5P2A+1bmNi5au9t4sJOz5p2M +HH4HdRe/6qN937BvpV9c+cVfNfGnJfBcSQ/QRQkf/1dG/e8SHF1ybWCHzd83cY9LxLjPHyx2HPq l/qqjXccPe65DJLW8KyPB792FuZ29Wv3Jebqqzbe85J0XlJZ4+m+a+OeF6/7pQG/bc/r4zHuQu/Z rmeAm8Ugv2rjPS9ec6sn3qDxp1+1scSvI44e+S9xnZejWDy3k7PGBY0cFhCEKSH8V20sdrKOw+W+ 2HTftTHjlIRIbeQUz/d+/rqN97syqD/IKck5/MlftXHHKdWocVsdPumavm7j/a6En851co6VvY3X 07xUjdtqIDar/us2lnkBaVX4w+O48z0EEx+EPSg8rATUX7Xxfr9AHzM/29ev27jjcf14C45xgPBr Wx+f23i/X6quUy3CPNeHGg0nxvc0LxJDMuLZMuz19nUby72P9TFtqfp9G3NenOScVakM9La1v2rj HXcBH6zDGnPft7HMS8b7AeP4Xh/ve7/OcZTFpuNtPGHigrkOTFwJdMEz8VUb97w0xKEgLxpY0ndt zHNscGQLnox7TtfpV22883DS9K9rG+q3/KqN+xyL4g/KWrDaTSLNr9q47xdZY+M8w9xqzARt4yE/ KmnBs2EvI0bAf9/Gcu/PcaDo2vM6fciPSj8ZmPhgYJf8uec995gfNfdNmxwAz2v9IT8KBZOvcdTw h8fxvvdx305y6sT08Zs8HI2FA6Ho/d7/qo0AzWp+1sCUtjfQd23ccX1V/UGj8obYQUwfv8nD6cjz TCjiSNf6b/JwhFh87Lnu/6g+3vGWM7cJeGVbx3H42Oi8DP+c0/w5N/1S37fxvvenn27maZXv27j9 lll9OamvhTy+auN978MeC5PPoH7dxttvWbHGpj6+b+Ntj91+umrvlyM2kNvJRXNER2yPW4ltv2rj nheH4q0trfjtd23MeEsnPrai7/4/1sb73odv3M139vffcsdb+oL87Bmv/X0b73s/gv9j4qbrOi1b j49+GMntlvsWBTK/b+Ntj7mZV/B6vf2n37Wh78oqCQ0SB4Jcr96+buN9jlWczW6N7fmqDbwrR2GF 8bNoYWEvbtRv23ifYx36gM9R5zYvWnv9xj+WlRB92CEztsd/3cbbHvOIgd9iar5rY773Jado+FHh o9f3y1dtvOclI04axZDc999yv/fzuN/GOLBv9W74qo133DjI2NvkqmhLG4eP7ekcK07jpCfWGP3X bbz3C/ZtRcyErtPv2rj9lk79HzGtsV9ftbHsFxSZnn7L/HUbb7+lcDGO/MrwR8fx3i+IG2/w9W3j ON6mPGZz5IsFsQ871qmLX7ex3C8vzEu1+/Y3bdz5YlV/uo3756s2lnnB+ph4VPq6jfv9EpDf0CM5 Pz638Z6XM6fo9djGYzyuYlrXeLZ47a/aeL9fwFEVwTua/0Ab8/2SvM5LDmsh4a/aWDjMdJ3EGfMd vm7jfr9IW0Mf8y3Wv27j7U+exQwmv4OssYLR7nP7epgXKZgy+OnAzaAY31dt3Pvl5ndqa17Sd23c 78qufinf18IMX7Vx22Ohz/HE5Tz9qo17Xgp+Cj53Y9FftfHOf4E/2SNHU88gtLFj0Q/v/cH/MX56 IWR5xwd91cb7HPP6s8+1nr5vY+ZXSkH5ELRA1Z3/8lUbd/yY5PCMHM0xnjue7qs23vmVCfmmM7/y e33c+yXAHzTPoG2/7G20Y27vOFjh6hpvsvRa7oav2njvlzLzkcsfbuPm3QDnTkIu4LZOP7fxzuML k2tvjUP5qo37vS8xeeMsxNtUfTlftbHc+8iLLuv9crTx8f2SwSlbpDLE2+/wVRv3/VJnXjTygTrT x8f3S9Fcs5iFOOid2/RVG+9732M8fX3PfdUG7LEildbk/ZLTH9Xp206uWKewHbZz/XgDPdnJWXjy 8s1noHbyV20s70rNN925GL9rY74rhSdHfmobr+/bWPB9tZO1WPi0pb5q435XClfGNS9TpyF+3cay X2AXIlbBr/Nyz4BG0R5z+/bDBJ2XyX0cX1+38X5XzmJYMyexfd+GxsEmScyS/EYUZIrx6zbe8zKL SOVu5+VzG3c8jMN7v1YUlMpft/H2w8x9G9d3Q120Nv6+LL8Tf3JFnji4wrdCN5/buO+X3PJ2R21F U37Txs3lmmBbTn9h+LqNZV7aco7M99xXbdz3iwvIJd5sy6/aeO8XN++5NTeBtvHs5597P+Xf6ZT7 +eXdojhymOfpH2hjzosHD9rETeWvv2tj4SHReSlt5dj9qg3My5sToeOe+wPjeN8vCe/KGfO96mOe hR/PsQTe0SiGqcRdhK/bWPww8xxbz/Xv2tD7JSPXK+v78r6jvmpj8Y/h/Mj5j7Zx+2GEByW8+fr8 9zp975c2uY9xjqWljeMsfPTzlw7/GOIt69dtvOfF457b7v3v2pj3y6ggOu4X4SHzR6G5z20sfhg9 k+uWL/ZVG/f9Mu2yGYcSv9fpe17CtIPWnDMJvgrx2gg9XZZra+1/WNGn5ZdU/PmX//Y/sP5TuGyr Wf8pRzf+/6XTkP9n/af/Hr9I/ad/+W+k/tPr/+vKT2HfPSNfzattG5SfpuUPtZYW6ayIYAFzYlcE qqmn8rfSTfMhRkCmcMBpIdvSvpHGrZq1POy77Dyibn8jrTwbQatkS2yo8q3VTzWE3tIdnibflIWi K3JfKaMX5xYRnet5D26Alvl3M1aRkeFYNRosQOdcmsYsFaFHGEX7spTFHCMv30iL1ro4p16jNGFD lmX8qu+ufSbBs/1lfyh/cvlq5IqD6MNapLMySRfKaM05P7LG/v7SEKnXG0/7jbSyXRQhTpPShfKa dVLRk0hT215hr6G9hJpXhdcAoywh14wJQ8BlgEp2/eNKpfwgRahNZb5lDE7oBX8vrTofJNXyKkrq IRk6Z98Ne5us1DbjFlVrnIOcMnn4QeNcpO+skWCVVnLhMfnlR8vvaq1ykf7AXX6u1C4P2/EdPwkV YChbJ+f+6BLeLF8gfHtjl7DTgbN++MHQKafGz2hOpL8Z+eTdgC8euNxI8WpfSE/GjR83vYsatVI+ sKSTE3kWAE7Ki1Er1RplCBnfLRGq13cr60qjOjcYgOy5LNQC42fFucbruZ3SejrUn5ixWgqq0lHm f85LIjPmdeSaW9wCm2/OSHJpTbwGw/Ov53npVJpykfj6kyTHYTzm0nPfJtNLd+jImM2KbAXV+Qd2 XHs6iJJkzWmORtu4/p6koYek2SoDadBM6NqfWVMXadVDVg7a8S6ffbP55hldw3aQLM7rYJ8IK1vn nO9E/Pdat6vPOlXfjByMI+MKBuu1rvNKWRY5x8kYufgjxshfH0ZO2U2GtCAPZe5QzsrMcemi8zvO taRxk5nWLeFI8HWMyx2qj3+dbzZjBkvCDexm0WfhqbmLFB/SnJ2qSYK6SDe9iSplPeYcbFJ7Blau ni1S9sFKU/a1YeVFZfVOKHO9VTS8o9bOkc9zTedP65i9Y3cP6cdT0eNU9EATKfsTfxvErJb1iFPR nGev1v1vpccdMlCVrtE2cpf4n7AxlHx+G8RxJDd5GyT1uXvKj/RQZTRqaelRlUZ2ixDufyGt9UWz EG4I37byXgRRr5Vm1r1oTdmxu0bC+sa1xqz7S1qw49A1p2BI076pdd+ViVtsJ2WibuEraVj3MWJ/ N7X2aqOch9S671L47zXs86ovyVLpjFH7vF63XpSd6mAz9Y3j47N9XgUQEQt7ni2ZMulRC3uEYrxw tmjedVO75ZSmFnZXtk2RdoR55rOF7Sc3Qrnus7RYXIf0g40cfoqs4CyLTGwmNt/cyh2F4iU3OigP gJNH3e+lMRYnD5Ix30XRl0pX6oOVG36iWPdVitcMafU1/k5abceRiaTeTgcbmTKfPVi58a6hUZUz oFKusQc7NSAj47pDsUsoy9iDrThjQy5pfQNXyuf5YCuOxZY2y6OwtfZgK3atF3hJ33VP2Yw92GtV KwUJEwYyUZ5Z74y91rDWupi373iS30i/IyecVhae91hkO5Tba4P33KuFnfQmcu2ZW+6014TlBpVN YSN3OnJur10jn7kN4IHkXIHcXhsValEZDeyelFGX22tVqNHlPC9q9ZTAVgu3mboUC9Z9HlbfnpFm NtO4x7pyeSJ3wVO+R24zDXbEMXJBZvQG9uvI/fzXTzbT8GH+0vTN19tDBunwO2lZY4PsGhbXNt83 KkS9VF7JVMbrBrUO68Y/OqW5xyQWPUul4oje/pRN7eE1d0241H8Ad7EXesrXEw8S+W618iMqo7aN neZ3WvPTuq/w9fSVd+SIBTRvgyYeIp12kaYsP9wTPE4FeVFdZyvimRKVfhr5iBr4peCbHfmUfvB5 dAH7lVNHT8WNr2lK8x16vUuEHe1aNcg2qH6dsRkJ/jhjrkHnsJm2vu8T+LVL3y8K8ZgUIZnTM3X8 xckG8LDOncaAjNtfOR5qZJwG3N/SJPF+/Ix1MpZ7Is39DlefyktTlR9meAbbIj3X2rPWimptZty6 lTmg/E4afuQWYHFtOTdPnuBbWm7/6U8e9vnrC+nbjywzNSgg8A6ludPcI3qd5/onDSmVvtnIH+8S tfr8tPZKXHPAnlbLnG/f1YfdJnNNoNIfT+Qi5Q/0ZKqL9G9f0E7Pc/EA/7rZrY/spCfpiD0mXliT SzylT6+F7rmsEcDXyLvq+NolLJvoebV0/e78wmpZpX97OuBMbYgkbp1FzfMZG+H6VWesYIfS/IGn /T2CymWtBY2mrp1lYzz6evRPTo4F8TOtsXLzHnta5yPZWaQTWLT8GoX929PBq+0QYTM1z2Jjn08H zBhQhxb8F9L3/pb57hJ6pfubSfMIoaynv1og8t15i8p7uonmDVzEc1CEzl7fY3WRflprs28XcZdM lGmbsd+eqXILZLXT3vcYpOvvpLNK1z7Pc7FbKlbJa/nJdmhSv0Nz+t25sviuR/+a0/M8TJtJtXZI 83WelWNBdolyguW6xi/+VmtZ11oCozrWWv1Oa9HrudaRRw+rR+CmEK6TJsVSrwsm//9CfMz/23/9 13/8l3/v8J/P8T8xFR8r4n+Kv47WEf+Tc/yf8T//PX7t8T+6Gn4T/nP993/4D/ov/8NYN8sf/+Nf /vqXf/3P/2gACjePIdyB17EGCh/8ER7g969fgwIhPzQUfKqpxXFxSEOvtaHQX6ahYsMOyIj0IHo3 JHWp94b8Q0PriNL1QOlbQy2eDV2X9WzIbw0dOlrFuoT+EB2d/l4zogBPwntE+RxRvIwPA5ebEWWp YbGOqKajoVz7Q0PriEaivN9GZKZ/wGy80Ng6Io0sXhuq5WhogF/zZfo8ogCev2VEr6Oh4dQywDzR kZLKLQ0ZHSWro0h05E4dnQtybShuDe06yssIfilx7aGj/n6HPo8ogDv0bijum010ZDftbTYuOgp9 05H35tOa3WuJ6Cgeu99701AwoKUd0chs3T7Nu3OvjTgmzpDzcR35fo5ocFUZ2JzoKMa6NdROZTMd ZaajuK9sq+xl0+atoV1HxaW1IV+sjsL91noeUQAH/tKQXUd2rxWmI7+vo2LXEYkTYDo6Zo009FZ2 2Ro61lHbjlq/qUgaer1fGM8jCkK/sY3oVPY4Ms9Pq2REfTlbRzRfNOuo2nVUzYjSvvub1Ns6G2p3 Q3Vr6IOOmqj2aOg6M+d74nlEAZ7Dd0P5HFFM4TnQY1lHxW3ryPXzgixkQTYzogzs+W7I12waajaA g40oHQ29TEP2qO1sRPk3e20EhZ7WiB1RQcDuMqLzyh4JdQZnoSPaN206V3YhJ+SdbrHqKO4NBduQ VbY2dIwo7gdbONfROv1ha+jQUQh7Q+cxMghXT2uEjmjZEr+0duk5ImLVeqIjv89atCvbriNt6BiR 2z5NocwnHcWtoUNHLu4NnbM2As1Oa4SOKO2b1o4o2N3vp0Nl2/3xNw2R3a8N7SPK/bcNFWON2BGV n7IebFpi+dQR8d6bEdWflOrnhhrba5HoKGyvI28MLaqjaHV0NmS2yKqjvDV06Cgcu/882EbC4mmN 2BEVjdxdGopmQaZkP226Mzcd7UbEZvg/btpEdJR+c4ysB1vZGjp1dCib6uiwRuyICvzoH0ZEdZTP ESW4tZeGjA0ZyJmdzxEl5Au9GzLP9fH3pzViR1TMBWkaGh7p0xqxI7p01HZlm3utEmvkdpPeI6r7 49hPB+vSUBnG6OHrtQ2VzUQbIUBpW5KibPKmNedRux7R64gSElbXEbn8wCeyNxRWQ8srMezW0GC7 fwzsvRu6vqW+7+zR0GpTYtbSE4PW2lCRus/zj2F60teGKtm0E7x6N1R/VmWPyPbtqhWMvT1yEi8N dcnWvhuqiPLeGrJ77Qal7oakvO67oRQlSmNrSCz/A/u2DUlkqX835IXGbmtoJNg8hqG/G4rXHrkl f5XB49D2hrIrj3VnlqO2CJPM/GMdxRqOlT0Cjx+T6t4L8pr+9/PosjK6BKrvDfWnCnjb9Oeft1Ku P04Cpfv/CDnlYyjQukWWh/5Y6C0cszZQeB5bs9/9pRwNuVPZvT+HNi3nUSl5ayhv14hcR+GhoWNE qwNhnEftGNGoxfZQDmoZ0eBoWA7/a+u1EPaGBnEc581dRzTI+vPWUG7H7s+xm1AkNqKQ14YKSiav DS2z9mlEbvWNjIbsveafSgHsB5tbj5EZrLI0NMiGOWfaOqIRtZqXLdIl8GZv6LKfH4pGrCOK1zOm bQ3lcx2V+tDQMaK4KrtvV7g2tHi03nZ2OxoKWQhUbh1VEMguDQ3WwAee3/XT2uqcH+nJO3owRnQ9 DXhD26ddDS3KHkxZ56Yt14J4YFI9zuzlYEv+cETKmd0eShZtAMvAe9+zlv3xYJMR2dgQfh29TbZf KUtI8dbQ2EK8oW3WkpSiWxvKx4LMl/YfWLSOW+TtGv9VBxZ96GiEE3A64c1gL+tJNq6jks/raBxs hTW0zdpmWf0q43w6blpx1dOGtllL6+n/qzSJ4911NG7aE/G399pIor3n6dp6o96c3xrqw+l7hkwg EXdZ2dUvY7iOp6pRJ3dDGsD6wLWxXpBBKiHeYn73J95XNm1oHdFo6P3UuxoaSzvuDSVvjxFyZbfV WTfSEsMxa/X6VB5stz8h8oJnjIiaWs5Zu7bDY/zZemWHfUTbVtMrOz6E2B5X9mIOS0OnVbs2ZCJH lgvSxb2hWswt8t60n0YUQjwaOkY0iBWmNWKiUZZZcyt0KEm051Gb3w+/Z7NmpHzvz6xw3mvypsW9 9mkdBbc3ZF5HJb3Nmj2gbNdRXbfoaMgf91pxb9/IJx3FvNuQoZ9XdnuH/phgreUpmpbzZzQUz2dW XvD+O/bZuFjrDtRJsvqxRcbSN6GpxsWqnP7vhjRvYGtoJOGde42NKKx4v8+IX98asuHsbEQl79Of zawNO/vYa1RHxxOinLeIWP7HXqMjKrsxGsoxa4NZ49xrdkRNCjnsIzouyBKL2WtsRKmus7ajEjqi YWcfe43pqPhjZZ9XtniPj71G11Fdz6MimNM+ovGEOPYa01E619F5Hq2wWH5sqGrS7d1QFefMMaJm 95ox2JvQg70bikcIghjswe414j7MadeRO++1EUto9poZUV1f6zKiYky/EOxeMyOqUuVxb8i8IIvd a0xH25Udt1c3VjbZa2xEfb0gx817ruxxQZ57jYwop3WLRHsdlZTsXqM62r1+3R3m8ch6NXuNjChs DUV55+0jcsXuNTKi3Q+Z7TMrXbeD2WtkRH57QUYwVa8juqwMs9fIglyjKVRH58puye61Zke0Ys5C ddCMfZTtXmunjtrmClPGpPMtEpLda2ZEHWyis6EgxJhHQ9Y3YkdUf/xm54/MndMPOe7+c68RHfm6 734TyTJGaPaaGdHg5dw9WrGcD79E7jU2Ir+vbJ9OT4S3NiSbtbBN/3DWnWZNsjYkG1H0hxFh7KOS 7F5jOnLHOjIu1uGtOfcaWUcb4DvufgOwXE8Bs9dIQ6vJKFatOw42WZDHXrPOOu9A7Ig/IsdobUgi oo69Zp11TdMP7oYGWcYx/dnZ9xpzH7rtGKlgnF4bii+zRfinvR8jkjttPOzFbhH2aWmb/suoOB0I wzVxbhH2aX1rqEi9ha0hiUA4tggbkc9HQ6c1MvjZzi3CRlTTata0H7fqWv1H3mwR5qvNmxEx3iam oWy2CBtRPmzIHYMWg91eRwxfW8PEpKFm3D72mRXJcz223Yb09XzTpmK3iHmKXru0L57R4c8+I1kG MZzZImZE8mRcRnQGjU6z5vSwmxGBdWP9tGDsbLLXiI5WFEzWkTfGaLR7zeoorpEik1J3/7Qe7F5j s7aKjd1vwqoX15jfGjpmLYRlRP2nnA2JfXTuNTKiLWhwsE/0c9ZctHuN6cgfe824WFOze82uo6iZ he9Pq+7YawJnnHuNNbS4Cx/gDBvtk8x77TIaw/vJOKY/G9Ov2L2WzFN0sOitew3Zr/uIrOlHRjT2 2jaiaszj4Ro79hodUYxlbaidyPF4wJ17jetoQSEGF4iNPrT3Gh1Revt9pKxrNRZbNnuNjmi5EQX+ P99rgzj93Gt81taDrUlRZavsY6/REbm4bdoNFbsd48deIyOKUjNzacj6Rlowe42M6Hp71u1g8+dz vUZv9trDgnyLDVqS81EjqZfnXmMY5HZlNzv9Y6mbvWYxyHDakM6iomSv2RH5627f4NVsPKPd3mt0 RKUvW2Rklp57rZK9RnUU9oPtfK7LCXnuNTai4OraUDAjitZV/82I6gn4rtmvfmtoG5G/boltRCbW TzwR516jI3r7oYVl6PSxjY7MXmMjan0Z0XWMxOMYoXuNRkT17dPyafkPUNLsNdbQAmdJOJLZ/cm6 NJJ5rw1ysOWovXSUzoZasO7DZJ6i4gxZRlRZSAzZa3ZEXi7AZUTlBKHK4okIW0PHiEreL0gD0wcL i1Edub4dtfkM0auV7DU2oiXxSC228xYh7kMyonRZ6NsLcs9hGLNWvd1rbESxb9bIcvFiRJ7ca3ZE AUzEbx2dIxIj4txrdkRh9WEIXbDZ/cW6D+mIUt90FE6DXeJqz73GFmRyy8F26chYbEtY9R3KYN/9 YVWKVOE8PRGlWfdhNm/a0dB+r717WT/t2GtkRH7N8tJ6i+eIBlB37DUyIr+GQ8umNaHnxFXPdXTY kMaqTcHsNaqjJb5DSwad51G2vhE+IlfWhnI+L8hk7zU6ohA2Zdd4bpFh+h17jY7IuW0dJQNBZwuL 0RGtMaPjXjtd9ZVA0HREPW8HWz9tyJK62Wu0ISFHWRoyYYzBhntk5onodRlR29xA2lC3kb6ZvbL9 FjNKruzu7V6zI/L7ld2EXXtvKDa71+yIBhf49l4r1mKrdq9RHe3KrtlYI9XuNaYjtz/XTWClhJ6f e42N6PBoWRtyiT/yW0PnrLnNiMinA0EMrXOvUQdC2c6jZjyj2b7X6IhS2p4Q9fRDjswUs9eYjtK6 sqt9ZklY9bnXWEPbCxJVP/ZPs3nZhT38lueQPGoMdFhsXnZhb9qetoPNpfNRU22EJhlR/In7K9ve a93akGREh8U2dGQONm/2GtVROvba6asdnGnnXiMjSmsMzHhl+xPLljDGY6/xEfVt01q3T7T3Gp21 LanCbfFIr9tiO/YaHVFx+8FmruxqbUi+jvJ21Jq7f+Av514jIwLj1fvT3Onzb76ZvUYaGtXsNh35 eM5asT5/Ep9dL4M9bA2dHvZWrA1J47NL38ya0ow/29qQNGJ8SVkRHZktUmxUPY8Yf1uN2pCJZLG+ EaqjBRcTBtAz2qcRnz8ZUfrZMqGuLfLVXmMjWr3Hwth7vrKj9UPyWdt9I/58QUre0bnX7IjKtSCX YHi/Yds4ai2+RkaUV/BadBTPK3uQu5x7jY0oxO1ga6d5PI5Ms9fYgix+u9eacfsE6xsp9uFXlLV+ jiit9+UL55H1jRT7pk0rnK4eLePQtGGMZERxZfMZrNPlfGVL7PG51+yIRjX69+Ev59F51JZm9xrV UV90NIhTz5s2kr1mRzTo8nbHuMEga7V7jY5o8fmjwsY+omRtSDpr0W1Xdo7nXos2tIqM6BrCAoqP hBZjZxN8jY6oh8UYHQktxllnfSNURy7vs3ZG1o3SAWavMUdUW8/sJImYe0Mv6/Ov9uFXwMSJhiKo 75eGqrd7rdo3bZSwoHVEpx+SheeTEUUpULaMyHL7FGtD0hEtwcfSkMH7s/WNcB0tYOZY2ScoXqq1 IcmIrpMsbQebCYjLxfoh6YhW30jIJNgr25DhhxEthlbcMzwVYLFxI3REi5tPqrKf8ZAl2DBGOqK+ 4P2XjprxRLhk9hoZURYAZdWReWYF+14jDaU1kE3W0emrHWH3Zq/Zh1/ZkOPr08IZozUiv81es2/a vIZESUMmO8Pbe42MKEky4NKQsbOLt35IMqK4spbppjUXpPWNcB0tj+Ow2e8YUbL3GtVRiNt5FIyz Llgbko5o5a0ZB9v5OBYP+7nX7IjSdf9sB1s3yYLOxo3QES33jxwjBqlJze41NqK6PmoiwdeivdfI iK7X0X4eRbOym73X6Kct2ThCFHAm5pZm40aaffi13dC6dG/iIbONG2ns3d9Xg/0akXkdeeuHJCNK AlbeDV1bZD1FtCFrQ9IR5bifRybDd8kUL1tDRkdvMZm18+4PNjyfjGicrdsxkoyLNdgYLToit777 80ETM6M0jr1GdVTTdvcXM2vB2pBkRNfKXlxjQ0f13LTN2pBkRGWFHYaOsjEiCJZNRxTCdkLaxJMW zF6jC3KJo6aGlkSMn3uNvrJXJ8u4nczutz7/Zt+0RVjSFx1FC2baVBgyonG2bp+WzxNSYkbPvcY8 Ebnse80467z1Q1IdLZGUI3fdn1i2WGznXmM6SrsRYb1+w4g49xod0ZpNn6UO09FQtHuNeiLyNmve pOYla0OSEV1Go992fzV3P4nR4usobjdtMiNqNvaYjKhcOthG1MwFmSyWTRtaMpg0S9+sbHKv2Ydf XZ+MakOervoY7V6jb9q4XZDFmDUkPJ+MKG6BA2Ov2Rgtm+JJRhT3mzZuCU1m05atoUNHxS+flkkY Y7f4GhkRChEsOjJHrbepMHREfp81u7K7TTvjI2qbsg1BYCG+ETKisbIXZY9CDcaGtDFaZERlTccQ HZ25EAJBn3uN+o/yZrA3i67bVBjS0GGNxC3MGjqyPv/O3rTJbQdbPx1RJdt7rds37RYoIiMyHq1g qVT4iPrWUDVx/gRfIyMa1PDbe62cI5I37bHX+IjqZh/ZsKFk9xrV0cqBMJ6iBoMkNiQfUd6O2m6N CGtDkhHtxCVjRDa/3/r86YiK2/ZaNgFx2fr8qY7SikHGH2fij7KN87cjGhjP4hiXlX3ia87uNfJp beXfk91vSBSLxbK7efiFERC3HSPexEM2+17r9k1briNx27Tl9PrJrJ17jT1FU9mUXcxTtNv3Gh1R 3M+jjZPjPvzPvcZ0tKbly8pmUfXnXmMj6vvKbuYYadaGJCMa77HjgjyJlJKNh6QjWmmLRNksw/fc a3bWtsgleYuYVJhusWwyoo24Rss3ntgRwbLpiHLYHsf1vI5GRWez16hvJG9ndj9Tqgb7kKHkcY6N 6C0WqqXAYOnU2tBJyLVGIFxvEcPtk+x7jYwoo5oYGio/256V66hZ6gIyomvTps0+MkTchdiQXEcr BnmtBgPT12wpeZiOqt/Oo5TOWWOUPHRES/hZGHlH5wuy2bgRMqK6UV+OWTMpVcHGQ5IRXUNYz+y2 BtljRNn6RqiOVsRP3munfUR8I1RHay7ENSJrsTV7r9FPi6uP7WrI+I+ivdck9u08Icv6FK1rBDE+ LRO2amnomLWV/Wwo276OrB/SjmiExKz3WrGkHFIXwuw1M6K8BcSNhk6a2bWhsjV06mjdtI0QlgYb e0x1FFfsqJHnurOxx3RELm6737lzRN7ia3REK7nL4Ks14WfB3mtk1vrKnKTnkVnZFl8jI2przSVZ 2WeUhgQOmL1mRoS6oe9Ps5F1jP7KNnS4WOtqwE0dsb1GyIHjEnoeqvWxSZCO2WuMaNJtn+ZM1iGh vyIjqqihi4YKSTuL1oYkI8o/i0pGQ8nQqDWLZVMdpdXHdq3skyNK0qnNXiM6Svv0mygNCdIxe42M KIeyNmSQY5a/RkZ0DeGdiS0jOm+REgnVHB1R2Y4RZ3z+3fpGHnS03SImDVYefmavnSMaryO3Hf79 dGhKfRGz10xD42Dbpp9kHtgYLW/IOMNGvaxn9nlld0LraMg4hxGx3rR9JbB8vWft3GtmRJKMte+1 k7hE8kXOvWZHVFeWaZl+ky3mLZbNdZQ2ZefThqyEao7qaCkDNBqK51tEourPvcZGlFZXfRey/H1E jNaRjWhzsdY1ZgcjqjZ/jYzIr1XKHla29fnbEY1QurZ9mqV1rNYPSUY0PA3biLJBRaPF18iCbFsw /HhmGT/kwuf/1lGxI+q7fZQM6X0k7zVpaJu1vhaFkqP2vLLXYK/nEY34o9UNXUhyTrB52WREdYs+ DCMazVyQFsvmOlr92V1LRe+flsheO0d0GuzN3v2ibLPXyIjakr16jcjQqDEsm85ayvuVbUmmbdwI mbW+OoxkRCZsqJF7jelozV6lj5pE7jWmoy1i/BrRWc2D8Y3QhrYR9RUkXXRkWM/Ph1/YE3OHss+8 o0pyarSh814r273mzBZZ+GqfRzT22pLkFQrJXg02f42MaDg0twsyGmuEUM1RHYUVzRqeMsNcYX3+ ZER9ry8y6tsbgIXca3ZEbktgGhfkGVwht8i519iIXN0+zdQ8WGn4P6yjkY2zOxDM7iexx3ZEo6H1 lT0qlJqVTeiK2Yh82EZkk5c9udfsgtwYAsUTYR41xeZl+0Be2X7Nzqgr+RBGFCyWrQ0dOsrOrw3F E85YnSzPI9qTQ+VeO10akr1q9pp5ZRfBGJeGbBZ0tPga11HejFETxkjvNaajtpdziMbQKsQ3QkdU NmvE24hx4huxOhoUccvuHyM6D3/CgcBHtJ/Z/swUl4bMXmPraGHPD3WryIR1ZONGyIh2BpRxHp2v 7BFHZPeaaWhwsrzWhkxMRGU2pCnCIQD/dmXHU0c9sb12vmllQW46aicIVYMNraLVPMo+IuMYl0pe ZouwT6vbeRTOBKZhVNotQj4t7e9+fwZ6S7Uzs0XIiNYSPOPMPh1RrZJnFlX2viCtVRstJQ8ZUdzr ZjUbVt2SpS4gIwo/bj2zL5Py9PmLeWy2CBlRSdvu38g9dEQ2tIo05H7WwgCBkSlEAotF8/CLGwYZ RwqyQbNsKow2dOiou/3hd1ojbSl58TyiwVG4ZB5Et7EOv9Tnb6nm7IiGr9ZvrvpqPs1ZCJrraIHF Lh0Z6stKqAuojrYwxmoJAhsJreIj8tus+dNioy4NOyK/ok76XD93fyWuejuisNYqkBGZey3Y8Hyq oy0PctTNMuvIpsJQHa38kNeIDJWKBA2ee4192mr6xfBAo2b2mnmvJaGRXXVknhAkZFgbOk7INTUv jroQ5+uI0F/ZEQlD6Xv647jmXntDfK+Z5/pg4i57QwyEMnuN6WhxIFw62iKrdEHakGGiI3+dkMum DbayoOTUmL1mRjRSn7aVnc7pl5gIs9fYiJZgrxiIJ4LQOtIRrcboNSKTTS+Hv9lrZkRhpV6WlW2K lFUCi9kRhTVDYIwonEmnq3mcnxvyGwPKNSJDOCHxkOdeS+bhF9ZoijEiZ7LpI3FpJPMU9XtYdSes 54TW0Y5okB2Gba9lM/3MpWFGNNjuVs9ot2mwUszl3GtMR0vYquro/LRoKVSpjkLadr8zFBiO2JB8 RPtNe5IpyC1y7jU7IvcTl4ffNaJwGlqyss+9RtdR3EZkjVF2rzEdbZvW/YTTGJVApnOv2RFFyU2/ Gwok/iiSvcY+bQ2tGgfbSTUnjxqz18x7LYtXbxmRKeYyurF7zTxFh/W5NOTX8pBTR8R9aEY09lrd 9prlhyS0jnZE0lDeGjLxkIHYkFRHy+M4BhLt08l7zero0u4SDznMGpPj54gNyUa0Mg2Oo9ZA0N2G MdJZq/vBVs/kZdn9Zq8RB8JaNm2YNadnlN5rTEc1bNdRsdeRDRmmI4r73d9PDgRGV0waGqUOtxOy mel/2bQzSVM3I0rbrBnKwtXt47aGNh3FtZjYGFEyBnslBUrNiATL3o7aamJrPIGgzYjGXov7OjKU hYTWkeoo7Aa7tY+8pS6gOupLfdrobL6IGKNmr7ERtUXZgWwRz/YaGdHK7BWdrXUorjGz18yIBmXh dh5VM/2O+EboiMKmIxIMT2xIO6JBer/da8nAYsnSX9GG3D79pobvIPozey2bh19ayy7ICXmGn1VC XaANHefRQpsn55GhLfJkr5kRDfdhO5R9PkWdrcBkRyQNbZu2mAAUT8IYrY7yRu4yzqPTqh0l48xe YzqqS/bqmDXzzPIktIrN2lIidzRkKlRKvsi51/iItue6vWlJyQs6olC33W+3SCKwmB1RXNNV9XVk vH42PJ+PqO86MjT8mfhGbENhy8wcK9sww3tbWdCzWtDb62jYkCZIh4R72FrQw+l7uDSYoWX2GoPp +3bUtpNFrxBKHjsioRbcGsq23pGt4kl15N22jqzFlsm9xnRU/HaMGAoMeq/REZXtFnHmdbSsI781 dHpG9xEZpEawbLPX6DpalB1WNvU5IlIxl+kor9eRFls8dET8kHZEZY3vEI/WGTM6zj2718inbebx 9V470/IHj5GtTm0efm1lKtFN+9obGkE8tjq1edMOMs7lGBmTZA5/stfsiNyarC7XkSFQZnvNjsht GXXUGC3kvcZ0tJQ4kVkzrvpOfCNMRzluJ+S2jG5X/bnX7IjqT1+V7cXLs4+oWUoePqL1XnOW/kqS c869ZkdU1qKZemUbOIOE59sRjVy87d2fTWHJxqpTmxHlNWNJZu0Mh23MD2kbilv+2pg184LM5F4r 5JXdltjjFG0J50z3mnnT5tXPIyN6vfaGmidpZ3ZEbi0n9CtpvtLWUOrEhrQjuv7hIhbVQNsa4nuN 6Kgur+wUJRr/0BHba0RHvu/+o/Pwb6TkBR/RYtZcI0qmaGK3tI5kRGmtuqFA3XnTjk8ze42MKC6u +jQqLx+fllkqDBtR85s10k5fbSNUc2RESTblMqJmWPRIFU/6aWtedtxYjKAjlgpTzMOvrNSCY0Q2 D9ITG7Kwd/+C918jKmc0tOSLmL1GYPo11i9pVeutIb7XaABKXxvy56wNX5nda0RHbcnLTiSftrC4 ETuitKaHDR1lky7USRgjn7VlRGErWagNkUrwfNZWg33j5daGqB/SjiitTLeyjk4UIpOKuWRE18pe /ZCXjs5A7xpI3Agd0UI2lYJNPBmx6HavsQCUvOvI2Eed3GuVvPtXcuBxr51+SBnRudeqedOmtRr5 GFGxVRhIiqcd0bAalhPS2zrHUury3Gt2RKNi7vJp2x/RkCMxWkxH61tknJCGJIhh2VRHqwPhmrWz IYFXz71GR7SQ340RmXutEhvSjmi46pf3WlxJrDAiZ2n4H3S03yKm9mol9xob0UIIOUZkojSEPv3c a3ZEgxp8u2mzDWUgIcPs0/IKsCSbvUpjtKp5+LUNpk9b4QqMKBF8rZo37cYrqzet8bERfM2O6Npc i8F+7bV0OjT5XiMxEXk1/cibdthhdq8xHS2oaLp2zHaN/NIMF7vXiI7qCtQl4XI5dETiRuyI6lak bFi1hiCQ0PDzEZXtpk0G8CWlnMiIRoGJRdnJBsPnzvaaGVH+WYtKx+uas9lixOdPR7RQYKRky4EO igy716hv5LDY2Al57rVG3rSLiTZGZNI8Rj6j2WvNvGnLiqiIjkx4fiE2pB2RXymYxhZZYBKMyBOa EDsivxW6vRoy5RzGjWn2GtNRCNustdNgH/WKzV5jOiqr2yfZAlyio3OvsRGtHOMpCWneMSJiQ9oR 5Z8et93fbZKXpZojIxr8xMvuvzatJXQnWDYb0cJ0KyvbUPKQkvJkRKMSwPI6Sj/x9GcPBgqz11hD bbVqs02DlZAYs9fMw6+unvAxImcqeQXyXmvs3b+IxcxiIohvxI5IjYR7RH4t7AUdOZLiaUfkNuwo eUujNhJs7V4jOqqr5Z/WGkFTRyQVhukorgG6mZS8YPcaG1GJ2wvSpHiykhd8RG3b/dUUKonEN2JH NCJZtr0Wzys7V4Kv2RGV6yJbbpH8U42ORi6E2WtkRGvNzEtH8fRnZ0J/xT+tbSPyp8HOysv4RrIz etju/mju/kb8kM28aQcb43bTehsxbilUyYjCVhMqjiKur70hOY/MXiO+kSVnQWzIc9ayIymeTEct b7dIMAVvGttrTEd5s7OLqS5UiG+Ej2g/s09f7ag0afca8USUFRa7Ps2EeiZCE0JH1Le95s5UmMzS qZmOwvGCNEleLPbYjqitHIXDN0JYGYgf0jZUtyT4sftNKadK9lo/H36CqGz+I2dT88i91s2bdqPz 0N1v1hHB18yIxl5bQagukeZbQ7nakhdkRHtV4auhZlz1hdxrTEdr3lHaanFOHZH3GtNRXSGfvFaZ RUOZ+PzZiJYcKhmR2bQsRovO2hqil9Yiw2iI0YTYWWurdsc68oaHvb7sXrMjqmvui9pHJpCJ4Gts RHF1jY24JhMTQSh5bENlLbYqJ6QJz6/E59/Juz/57cw2oVXy7jd7zbxpt8LGstfOEQl2ZPYa8Y0s 58/QUTd2NovRsiM6olg7Ib+rxA9JdVQ2O7ufbxFWNo3qKO9vWpOX3UiJQjqipXiPvI5MSTDm87cj qhsDSiQ1oSop5URGVLfoQ7EhDS5CfP5sRLVsu7+aAJROYo+ZjlbwIGXCxxaIH5J92kJ1+ivWH2ff tDZuJBh+yNDXgKOhI4OLFELrGAz15SCpWy3/IuvvGJH1jZAReSFvuUc08pnOveZt3AgZkf9Z7Go5 2M5nViYlL6iOlvR58Y2YqjAkRovqKK5YdlmLe0wd2Th/PqIlSuNaR/0MGWZ7jY4o7bMWTRZ0tnuN jKgK7LWMqBoM0lk/JB1Rd9vKjiYxN9l7jY5oJVBOxTo0hz/x3Gu0oc0+KsSGJLHHwZJxjt2/jKja qjC527zsYKgv5dMWG7IK/do+omjzssmIrutoXdnxenQb96HlQCAjui7IxRi99lo5vX6ZxEM+6Gh5 0w53konSsHEjZERtKy0XB/Opye+3MVpkRHVH1+ua8IsRNZuXTWet9m3WumEaJCUv+IjapqN0FgRk 7zU6orbi/WV1lGJE2b7XyIjGCblY/t0aEVLxxOw1Mv1tTfLqtv6apHiavXY+/PaEfhmRKeBOyssE Q30pjMmbS8Odngh+rxHfyApnDP/RyaWRg6VQJSMKG94vT1Gzae17jehoUM3ts2Zq+QRLw091tFJf xkY87NG+1+isrZs2dev1KyRXlI9otSEbSTrNtuQFmbXLPlpnrdktwvA1OqKl5o7oyOAikd1rxDeS l3KgY0Sf/Ef5Y0OrDdlIBaZkff7BEk223VdbJbrj0JH1jQRLfdmvu385j5oNYl6Tcz6MaCQavcXG e+1MYVhhsbA1dPpG1k+79toZMb5ekGVr6FT2fvc3s2m7jRvhOsrbyjbliSspm/Ywa8vurzayTmbt 3Gt0ROsJ2WyhEsY3Qke0gOBjRMHgtN3mZdMRxTVf5LppTbJgtTT8dERrHuSw2AyaxWxI21DfeI+H s87MWrK5osHyQ47pX07Iam8Req9Z6svBT7yNKJ2FAdYEpg8jGu7DLZLFG1SU2ZB2RGGHDq+9doZ7 8L3GdFS3lZ3O0CqpeWD2GtFRWuNq+5oUPXX0InvtHFE8ws8GwbeJG7H4Gh/RGlfb1ngUjCjbuBGi o2FobWe2IQcuju01NqK4eY/r6RpjFKp8RGuk73iZmnrZNs6fTv/ieVAdnZ4IwjcSLNFkX4lFhzXi TzBzvfvd1tCho7ae2aO6A+PPPveaHVHcfWzBpuYN3j+z1+yIwpYvMjbtOSK615iOUtzsbH/SzWRC Dc51tAAscRSHPWatkZIXfEQrun6N6DxqZUTnXmMjqvsr27DnjwVr9hod0RqkM+4Cs47IXmMj6qv3 uJAEJm/j/O2IBpmP286jammLiA3JGnKr97iu2UMYESlRGAw/ZNyp5tK4sk+PFimbFgz1pYzoLTZG dJ7ZLdp4SDsiKd6zoVlbjM7zXjOv7LjRp6dgiUtyslg21dHKoTl0ZCsvW58/0dHGnTLWUTNpZ4Qa nI7Il23W8rlpC+GHpCOqa0LlVhgeI0rkXrMjut79u8VmcrMKyRXlOlqx7GIjfVu0cSNkRG7PPBg+ l3NEyfr8aUNblk+xdHwtW26fYIgmoz417xE1+14rCyeL2xradBR2do+yFtLBiNh7jXFohvU6Gu7D 801L9xrJF9ncPsFSg+fUyF5jOloxyGYLuRVSUp7qKK7YUSX5a5XYkHZE42BbzqMBJBur1pbepSOq u4c9nE/RkUFg9xrR0Za/1qyrvgTih7Qj8mvFrbGODK1jK2yvsVlz2+vIkJVLVL3Za0TZefdEtPN1 NNar2WuGaFJ4QTb/kY1kycTnbzg0x4hWz2gTyPEYEdlrjENzyVWX68iE5ycbo2VHNBpaDXYS7rE2 VLaGDh3VvJ1H3uD9hfj8mY7q/l4Lhq6YYNl0RH2hm0mDTf0cEeEboSNay8rGJvD+PiJSNo2MSMk2 lxGZFE8hUjr3GhvR8vQcOvInc4Ws7HOvsRGtXBrXiMKnN21+bsiv8NWDjojP3xBNDmUvx0geLMOn Pzva/LVgODTHvbYGMnkbEiPRPmavkRSGvOaLZDtrORIs27J6xrXilvhGTkcU32tER1sWdF9L1U8d ET8k09EG1HmC1FRiQ7IRlXUddVKgNBI/JB3RnncUDKsnidGiI8prrF9f0Y1lRGavmRH5tS7RyDps pvpiI+81O6KwJmL/yn4lsZojIu812tCqbG9zjsUTce41QzQZ47b7syf1IBN5rxkOzWGNrK8jZ82a lWjyeUTCpLMoO1921+mJiDYe0o7INuSNMRrJXmM6WsDrX3lwaRhKZ5tTQ3XUV1hsMA6cvtpO7jU2 oiWwX0Z05h3RvcZGtC7ItBWJeeEWIfeaHVFYefdlRCZGK9oYLa6j1YEwUqoM9aWN0aIjWjwGMqIz /Eyq5p17jTXUVmeds6WcxGIze428stfScpnw+RdSXiYYDs0RIt63vWYSmFoi9xrj0FzL711bJJss aBajZVk901raVPaaSWGge43oKKTtPMonraPkHZm9xnS0hnq6NWBz6ojEaNERLQne2VuARV5HZq+R Efl91gx21Ej+Gh2R20fkjW+E8B6TEV3Tv3BpXCMKp0tjRAPZvcZ0tKCiY9Zs+T0b508ails09DWi zRGhNiR5rxmiyauhBZaXEZm9Ru8186aNki2/jKie1kgLbK8R38haNm3YkKcDYTBQ2L1GfCNl32vl TILPpBwo11HcZs0ww4+KKHavER2VXUf9DECRWTN7jYzIL6HnY0Tn9I8O7V4jI8ptW0fJvCCj5UAg IwobWfkYkcVpLRcrHVHaR2RiRoUjyuw1NqLl3T92v4k9JrzHVNkpbVZtPFkZxoDNXjNEkzFuMP01 omJyIRKJGzEcmoMYImzrKJ2GVotkr1EOzdXDHtfkMW1oHDNmrzFWz9h3Y9TGHpMYLaqj3fI3jExS 8uLca1ZHg9tnu0XME0JW9rnX2IjyG08Va8TU8E3EhqQjWq7skU97BjFLdaFzr9ERrWd2sMRu6zqK W0PniHaWmLzu2fvuP/eaHVHeCt5kt0YQY0SdYNmsoc2ffenodEM3wlkXDNHkaChvI4q2FDjxjRgO zUF5Ura7PxqkhuSv2REdfLUj69C46jOJ0bKsnmkPhk/23T9YP+1eMzoan7bpyNQXKSxGi+mo9+2E zGf0YSMlCumI+sIOm90K284Rsb3GRrRGH3YbodlYjBZbR26pdzTW0RnGWFg8pB3RzhCXnPUeD1+e 3WtER9HvK/t1NDTi0exeY9O/ssR0WxCwkZpQwRBNSibuoqPws6EZjz5/w6EZ90K3Y/cbmtlG4kYY 9WVdow8HGdo3vhHG6pn2lPN8WmwUX2M6SsvuHzoyNcVJ/TWuo7jfIuY8aiTOn87agkJcIzKlLqWG 77nX2IhiP0Z0WiPNcrE+jGjzRARTpCyTvWZHlPcoVrWG9xFVEufPRrQGMY+b1vghC7nXbEN5fQ4J dmTQLBbnb4gmRy7eYtYM+8igosVy+wTDoTlG9FbuGFEwIyJlru2Ixl5bn1kbD642NCKB7V4jcSN1 9USkn3IeI8MQs3uN6ahvsxaNnV2Ib4TpqK2hDOGnmDM7WW4fOqLFyyfryJyQheSv0VlbjQhPmE9Z /hobUc7bmW39kIQfko6orPZRWF/vGFEkfkg+ou11ZDIPCuFiJQ1lcaGuOjpTqkYsut1r5uFXrpNs 22v9pJgvLM7fcGiOhnYKjC2KUXFa8l6z1Jd5JamTiHGTvxbZXiO+kZr2EZkUhkjy16yO8lpOSHRk fP6kJhTRkSEu6YbXr5OcGjqiJV1IVrax/C0HAp+1hbcmMd6aTt5rbERreZk8ah6cI2qWA+FhHe1I jeHz75Yfkoyorm/PXznbUuCjqp7da6yhxWAfCd6GcSCQXFFDNDly8Vb/UV6Df5YRnXvNcGiOgCO3 rexmSxVYDgQ7okHttDIOVGvW0L1mWT3zVqpAUhhO8CCSeEiro7oic0NH0RSXqiQvm+loddVfsxZs BAJ5r7FZy6t9dDV0+mpLIXuNztoapDMoec5bhPn86TpaCHDGOjrJykVH516zIyo7cjy48MzKJu81 NiK/3iLZ1qmRCM1zr9Hp389sf3LVi47MXjMPv7JSMMk6MlFj2fKNBMOhGdtPbNuIQj1nrZB7zVJf xo0kSKJYT1jMkfcaY/U8Nm0woeeR+EaojpYIzUtHBjqUt4jZa0xHu9unnoHejdTOoCNachZkHZ1m zbqO/NbQOaLFpSHWyLmOMomH5DpabtpBfXnqqBCfvx1R3dH1bOtmyco2e42MaKkCJCMyHq1C4kZs Q3WNyBVyl5P5tDG+EUM0OXS0uOpzWskZ54gsZ10wHJpjRH3z+pnkHImGPveapb6Ma4UbuY5Og53u NcvqGTeW4d9t2rI1dM7avo6Ma0xeR+deYzpaCmRTq1Zm7dxrdETrW4SxxLD32v+nvbfNsWVJjgP5 m6uoBdQUMr4jtIBZwGyAaDQakgBOS2C3RtTuJz3y1DnmbpZVhxCoGQHv/njUo3j92fEMj/BPc4Vo YqtnEa9IF/U1iQh9yIq7OL8Rid5jeY6Gs35i9pqCi1WfbOytqbzkflt/tDUWZF/NkXHO6NVaBp5t jQK/sXP6T0SNhyr2vAjZGsW0EzmcN+013UdD5EaY+rLj6vddgqZpsSn6RpjV0+I190Ay8a3YnSF1 1LrXUUyM9yl8SKWjw1chUkQ0Be+x/mr+XTvI1sROKP3VPCEXBcezCw4EhQiJlOylpXmRKXIjEpF/ aYlE0dI3bGuEaLnm0ybc471ggmyNBE2kqNz3Udx2NsX+tUxEk9ZrjvFaRfLqb0QiN0IcmkZ5kj0i Wne1lK1RbqTjvWH8Rz1ma/ZeCLI1weqJnHWnIB6DHbybXurowOjIFkzQV2MuVq2j4ryRHHMjuy5C tkaI5lfDk11x4cADURJz2QoRtlbZsGC0tZXUuyYQTURUOH+Eq1OKExRsDfLX1zmKHtsUfSMKUV7+ qxE1+MG8x/rzo/UbiWL4arY0iGyNWT1Phx2zx/0rUx/bFLkR4tCsh+/2sZc2KHupHi2mvjQiP/j8 Q3DWFdE3onhG3ZhHF73HQ8RrSkdQBbc7e8agpgs+f6mjnt27dsQky1K5EYUI/Gr7apW8WvWuKUQD 3GNDFN2apWZqFKKGvTUdey2+EQkfkhBZOT25d404fY3TjmxNIRrN50aIJEjsqRGClidRbGKibog8 JBFN7jkzpyNK1e+vRrYWY1pbuYRrQZroq1UzNUx9aQsB/YQv9UOq+hqzenZPxTu4vGr+PNua0hF2 +/S9/TPoSPCNSB1hpaZxO+yezCRbE4hm8l+N+CGlrVEmwqhUnPWv2DRoPe5sa4Ronf6w87MrUage okdL6mi4kz1ioW4K3mOtI5/RajERZX+ZbU38tIXj1A0XDnzriH3IQkST1nECz5HpKH61vRQo2Foh Dk1ryoKBgU0QGGORxjM1jCgPXLVsk1DcMizmshmRrU4Z7l2b1DciatlaR9l9tUQkipltTesIqcGN jZHifu6HlIhwK4x9Nfb8Oed/89VARwMXVn4j4py/RhTOUfxqyod8B9GMpUObHY62xohsfwMsBWqn A0djZ4ltTQoq0301WOj9QDS497gQ0aR15VR4aScPVOJ6mcMJcjpKbmGyZSI+PrygjYhsTeRGFrJ6 Lj7ZNoXKtka5ke4rxxZQUo8W19eEjq5kHOiocj8kcyBoHXX/1YhJp/OsqESEsxB2jniJK+chb77a 66/VjsTMH687m2xNnSOY72+TZyHGwbkRjQjSh8qt2ToiW1M6yg7RQR6b2L8mf1pC2qL+laOgvS6d bC0GfntCwCOKxCWqb6QQh+am8HaI6GJbYl82I9qrUwI7bHT98oewNZEbQTbGU1Dl3mNla0JHbqbm 1BFNQYu+EamjglXRvluNvY4O5oeUiMD7NETUxNyB0zc5QQER7hWtHftRHohEbuQG0euvGSL8+k9E ZGuEKCGX025liC161gnMtiYQQQJ735A0K7q4li0EGVe9y7H1SOm8s37R1oho0nTU3EtLqbEuOOsK cWjWwJ5vN2S0tYN3+DIi27uOyToj5YjvmuCHZERmtEg2ZRnXWDzIXF+TOnIzNVPsX1vCh2QdZbdb zE42zdQs8a4pREDkt0827c4Qff4aEeqo831kU9JkaxKRtzUUQ+eoOEHhHE2kLerM6TsXx2sS0fSv CDVXqHhNCHJdy/tkx8T4OkS8RkSTxguC/tHYZRCPKPPujEIcmtZsjPeRvWsxD3lwnz8j2oTukIia gvtwTGFrom9kYCeL+ZCxR0vwQ0oddezzP981WgWeeFZU6gjqaTtbE5N11vnNtiYQrebPUbyPZLym EDX/imR61z5416FAlDGDuXVEW6oy50a0jjATcSKi3mNpa4TIJnzhq4m2IWNsYltTgoazNapCrMy1 7EJEk8Z4g3WRIc5REz4kcWjujVuvv3YiIrahBURK94hsnUN1tnbEfLa0NWb1HG4XdBUmgoK6ExR0 5PxskdAcYqZG6qhgHnKcgUDUUeL6mkCUz/cH/KMTUXQiNjlwtDWJCEo+NgQfwyzbn062pnQEWxIv RKQjYWvyHHkibqEjEa8pHfXmXhHiz94Lb6KtyZ/mM6Ncg6zMD1mIaHLPdYA3cl7+lGNLPCtaiEPT 0sXJ+Ucplg4XNDHfI8odR+iueC2+a0XZGuVGBubm9wMZgxpVX9M6wpz/Gfg5B+lT7zqUOpq+4kfs HpZeZFsTiNy7tjYFi0eUuZYtEDXPydI3iWdAJPKQUkf+XaNyhk0lsq0RooKp0H1nx2rWqsyjJRHB vbER0X0kOBCEILdrd1OoxhGGHdOSrVHgZ/xHPqNF+SOx67AQh6bpCK4Ry/lH+iv9rom+ETeXPTEt +fGwtSFsTeRGEhbFF29gUn3+Uke4XsZ0xF9NxGuso3r6w+7JbrEusg6urwlExXGx7pMdeyIEF6tG 5H3IEdk9dnWdbE2do+S82s4reLj3WCICHkfTEd9Hgh/yRkcOEe3L3iebbI0E1VOQ80acnEtHIg9J RJPbRHyOjW7IJt414tDcG9tff80IAuO7tvNH0daYi3V8Fejzb0lwjIudUIwodyK95wYU4UOyjoz8 zuePIse49CGVjjoKMn5IymcLH1IhAqqKbWvs1TKfv0aEDbpJdB8KDgSto+bvozh5MBr3jUhELZAE RWXv2lG0NUbUcJXgZ09iwUThHi0pqGJZLKENf7xONtkaBX4Nm7IMEfEf4YrCwwkK3oh7aRcnWayL kG1N5EZa8bbGozAi589crMMXMxP2NLOg7gSFcwRcTp/96lsKOhK5EaUj4HIyCgzaeKL6ISWiCrZm X41Wp2RRX1OIsGnQ6iIU9yfmQJDnCON+O9lxWmwILlZ9jrBQl7jZa7MykK0JHeFslumI1lwL3mNt IsDobTk2yrAnkYckokm72KZDRGP5qve4EIfmLoSAxzZFP6Tg9mFEe8k9+Eemo+hDqpw/c7EOvBIv ogBq9hJ5SKUjXFJ26mhwl4aoZWsdvf6afbU4Kmz7+MjW5FerztZ40a3ghxSIQqO3W+z1QCR2Z0hE yOxliDgPKXL+jKjhIoirUhP9bMEPKRGh538icgf71tZYUPds1QsTXN+IRG6EiCb3vKKztRR31KGf fThBQUcLPr8tBohJFpsfYluj3IjtJQITOZ/sGNTId425WPsemERBXF/jmRqpo364k33QwuTCMzVC Rz22n7U4cm7HjG1NIMIxjxNRjU2DeI6SExQQ5cPd2e7rX4h4pkbrCN+1g1n0RhG1bHWOpo+yaQp6 FZGHVIgaZLS6lSQpE1GFrZGgtofcEVHsG7HVp2xrFPi1vVgbEFGqXub8iUPTvtp0HluOfWy7P5ts jXIjE0fozNHq0Rux6jvbmpqp8eQuVIOUtWylI2ikNB1RO+zWEdma0FFBHeXTpXzHh1SIoJNyI6LM aFPvmkJ0OB0tmqhbom9E6sif7EHvWhM9WvIcQSxiRErE6C34/AWisedlAdERO8ZtVTjbmhCETMxG ERYJS3dGK9oaEU3ulZTw+a2plahUeFa0EIfmLjrCc3SIbh/BN8KIbBus3+bBvMfK1piL1argDtGk d60JH1LpCIfgz6+WKDpSfSNKR7X5cxS7oY32kWxNIYKKiiGqFB1NUV9TiIb3IWecOlyCA0EiQqJJ Q0S1I9WjpRB17/nXmBvZJzvamtTR4RDxVxP7sqWgmtzb39jzF/EaEU36mvNnt6s2Wn8VuRHi0LSy Q3IvLXXVryFy/szF2n3Fz+otH16QsTWyrVFuxK9w3pmI+K41kfNXOlpAo9at8zNGR413Qkkd4Q4W e2njVWsXFNsaIRpuZ2bPYjl5E/2QjMhmRd27VmNwvCNIsjWhI6wc97y9GI+oipy/0lHxmdFCFT/B eywRYeDXbXEFeWwiXmNB552NqwoK7/HbHlu0NSKatHAdEpp2jmiiTnCxFuLQ3IhAR5n7s3dGK9oa c7H2zSMKP23FcN1Go8jWmIv19CEhgrQh+EgQWJewNdZRd3uz7D76+PCCpA8pdYQLb4y6Pt5HHyJe 018N3rXMxCUWGZCtKUQN6UHzZgL3iLLwISUiSGieiDJbv8iNMKLhx4UKcip+vE52tDX51fClTbwY QPZosaDpYlp7aflkCx+SiCbt8zcfZce57DGZ26cQh6YVHaGN0UbzevSzBd8II8qnE4E1yI4b5i9B tmScbU3kRpo3WuI9rov5/IWOxqbbAx3l6GgNwTcideSo5jq2Iz101MW7pr/a66/ZV4tX7f5qZGsK 0eGUTTvFN+s52ZrQ0fInu8TGgTHFuyYRoa11bvbaiMjWCNFC8ozPXs8QIn41wcUqBWVsPW97yNAj mupdo8BvOSLuE1HrhEj0+ROHpgk6HCJ3Hq8om/eKMiKzteFtLVIXWBKYbY1yI6cg+GsmKFI71Slq 2VJH6PlXnhcZgvdY6qjhYoDzHDFLjOjRYkQTK3OGiPJHQ3DWSUSQ59mEXFHQ7hgnWxM6whvyRDSo J0LwaGkdJX8f4ZV96Ujk/KWO/MkedEM2kRuRPw1HGKrorVF9/kQ0aWFWd4g694yKd404NC1fmNxX KzFZt4roG2Eu1o6r3zeXRvz8dYgeLeZiDWkfWzgQdCRtTemoHV5H7I2IeE3paGF1vWES8KGjLGxN IXJViLp32jOiaGvyqxXnjZTYyrDErkONCIzWTnYsHmAsUpygYGsYHNudHS+2PeMXbU0iwrdfWb+K 10iQ7UoZ7qsJr1bk/Ilo0s5Rcjrq9K41MVNDHJonooQtepUXTKwkZmqYi3U40jJj9yATUX3+zMXa MRmyBX18REEiD6l0NLt71wZN06t4TeoIxzwab87ZNyTZmkA0PKIee0aH2J1x89UcPWiLpcP91cjW BCK4oz+7ETSpTATZmkIU/COqQR6ib0QhwsUApiPuYxN5SBJktgZ/zV4R7ogStkZEk3aNoH9UNr+E RyR4tApxaJqOpstEED2onMtmLlbX2rudCKZQFTl/5mLtzokwjy22VlXV5y91NNy7RvyQRtZJtqZ0 5PyjhgSWH69zFG2NEO0DCT6kkZZRzl/4kBqRe0V6rK/tDHu0NYUIWjtNR1zvV/GaQlSWs7UaWRlk zp8Reb4RQ0SNlYewNSWoT/euDZo7ysKHJKJJWyTqv9qilamHiNeIQ9N+GhIFWGdDRFREboS5WCmB 0GNivB0iD8lcrJ7R+xRUIr0DCupOUPxq0J9tthanoG0CmG1N6Kh7Ahyiv9o1SLI1QnR4z7/gHu5L ENZpkxMUELXi3rUUc7U2vMO2JnSE3dDddgT9cI6KExQQFYyOGha3vnXE/JBSR32EVyS+tKqWLU0E mwbrl8v5XjoSff5ENNkOxzLcBY3aGKKWTRyaLfso+/xpMaFpOWG2NZEbQa/WnqN4Q8rcCHOxTk+A Y7mR8NXMYWJbEzrClfKnjmgtyNYR2RrpqDgOhPOrVfKPhuiHVIjmcojIaMdQ75pChENeVVj/EDl/ RpTcrOiJaFEsMkRuRJ2j7k92j5nRPVFHtqa+2nAxLRWhxhR9/uqnIQ+7OVo8LSbykEQ0abY2nFe7 qL6mfEji0Nzb7Rzt9aKMVhE9WszFOpDyZNtaVLax65OtMRfrcHv8tjM6oyCRG1E6wl0+5zlK1Ocv +CGljtp0oeiM/Ueb+TTaGiNKyAxgiJi1aoo+f4nIr5fp8aftycxoawpRqc7WCmXYp3jXFKLkM1ol Xv5bR9HW5Mle7mSP2DSIdZF2L+hEhLWj8/PTfVQFtw8RTVr3e3bWP2iV0yHykMShaQ1HOAsxmGNc 9kMyF+s8vQbHokedddrWxExN9sWDRA/kFPU1paPs37UjNqBsz59sTekICZTP6J0465Z41+RXi5nR WBY7hA+pEGW0/slknLIfUiHCdQ52Z8emwXmIHi2FqGIHwhTVLMWjxYiMuQIqx/PriIGf7NFSgoan 45uxcWBPiwVbq0Q0eQpK6NWOTZgbEHG8VolD8xTkJljcTo4Hosy2xoisLOaZvUpUtnE9RVtjRKcg TPvYQGU0EZUbETrKvtN3INPTt464li11VLM72SRIzWULRNWloftQSxP5XZOInPWv02Ko/4jjNXmO Dnz7F27jeyDqk2ztRkfuq03uiOLciEY0HCIq+O6KX7A1Kaj4+4iamFUeshLRpIVZzZ2jFht09zki W6OYtjgK1TY2wYBHVLj3mBHFWdHJxQO799jWRG7E9fqJsfwqdmdIHUGAdt1HH16QtjXSkW0mcXc2 rU1TMzUS0coO0SCOqMkzNRJR8VS8jXrYM+chBaKCpJmGiEbOx2S+EXmOsN1jX7XxPkq8V1TqCIeX e/8a3BHFfSPyp3U/cp6JAUXsFa1ENGmhKPy1PnjBhOrRqsShaYgwVztw4cADkahlM6Ldo+U+P1Hx YlksO0GR22c5W6tx8qAOzo1oHWEsMjCf8K0jrq9JHUGf0EU3o25IsjWBKNiaa2G/i9c0IuxkOT// iOdIcIxLRKBcO9krVkXH5Llsiah5Sp5EPRGZfUiJqGRva/zVOF4Tgopvhh/IiPFAVMS7RkST9tUg DW3niPqPFteyK3FoGiJPWkb9kKswjxYjyuu8Ep2tUa8frk3LTlDs0WpOUIr7IOvgeE3oqCDN+X7X UEXXV2O+Eamj5d1j7qoXe2okIqAq2N5I/PyYY0tOENmau7NpwYSqZUtEWDo0RNFo99xRtDWFCNnP Nm0RVdeFD8mI6ia2BUQ9jsLMxDxaQlDDQH9/tej6Kc66SkSTLUyvGh1fjGkT5yErcWhachaGc5qb +fpGxH0jjGjbGuQhbecBpeqVrVFu5PTQgfl0E9/GodOD+0akjurhoqMS89lGJMC2JnSEDSiW9qGu +sK9xxJRSg5Ri11jxkDBtiYQYROz0TrSbrHKfCMSUYduH9NRdI/xHBUnKCAKhFyV+o8qc/sIRGUv /QFEBy0GELVs+dOAGWD3H1G3TxO2RkSTdh9B0veMIDvHtDy/VolDc2/bfP01I3WlWETsy2ZEZ5jl fMjFbEN1Ch+SuVjX7uN/CjK5cVZU2ZrSEbAwmI5KTPvYal6yNamj5N9+qos0kRtRiDA1ZoiI91jU 1ySijL01QzDoNvGuSR3BEHyfuD/5gUjsFRWIKnIV7Hw23UdiT41AlDcrFSA6KMoeIl5jQdU3xJ3n Lw6eqN7jSkSTu7wKggRX/RjMgVCJQ3O3iLsheKpmbcZKsjXRN1IxhFj80loFmG1N5EagS8wEUdIX BXUnKCaiwK3pihle1Ne0jiDtY2NnxKM1xLumEb3+WrdkXayKSlsjRN0tuzt1NGiavnLOXyMCZQ9j rqA5SBGvMSK3IdnaPY6Y0tizWWRrAhGUQffJpn7IwXtqhCDXbLwPJPXWFOYYr0Q0uRfSuvtoccVP +JDEoWkhBMz322geb17mvhFGdD5HDU92On3ToCNMH2YnKPaNNHeOxAPJ3D5SR3O6VyRR77Hoh5Q6 GjjmYcy80a1pXMvWiPBAupb2j9crQrYmECVMjOc98x4QKVsjRNWtcbRzFCd89bsmENXidNSIz79x n78+2fAcDdvsFBE1ZWvip7mLLWO95YHI4v5oa0Q0aV8NEpqGiLl9mPe4EoemIfLUl425D3l+jRFl R+G9mb1iI5N815iLdWHicY94xp8m3zWlow7+0amjQX0jVfiQSkcNdWTtSLGWPXimRn+17M6RO4/X VxPxmkIEBbVNyRP72FQtWyLCLVXDtdp8IxLvmkJUMcVqvRYxgTC4H1Igym4l2Kkj6j1WfP7ypy1P W0TEt4qLtRLRpF1s1dkaORF7CwPZmqj3T0/usqhBV8VrzMW6XLuHMcTFpK981whRuYoDIIiWlCkO BKkjmKIwHVFLzObSIFsTOnKNlaeyY9J3Np6p0V/N2xpz1VdRX1OI+nLKpkamKfhGbhC5c5TJ+iv3 aGlEkGE3mpDYMT4Fn79AlJDzYt9HdEMmnl+TPw2mKLbHRhO+XeT8iWhyM944RJWmDlUekjg0rbcG wixz/YhrrIl4jblYJ5L5bBOJ1OCyls1crNM36KZNUXcrqDtB4ashXbGdbIqyk6ivKR05Kl5ra4tf rQpbk4ggVT8ysoV+I+JZUYmoY4PuITjrOvdDvqMjRw57IeIeLYGooq+3yV1i9ni//dHW1MnGXYcn okKIDu49FoKyI723tz+eo9lFvEZEk5s56XX5j2sPgEeURY8WcWgahTe2nyVcpPPxuo/I1iKicrii uHFpxLKY6YVtTeRGBlLyJObQrEP4kEpHuHfd7mzaUSf21AgdnQcnxCLUWKly/goRDufYDRn97JGZ R0t/NUhp2MmOZFPWMsO2JhBhW/XWUVC2URCwrQlEE9uqBRuj0T+wrQlEOHhiJ5t2Z2Rla6oBBUnL zneNymJ2ssnWxMAAJEN2/oi56pWtUUybcEnmNpGY0piV59cYUbnmZUFQj2vTbOs921pEdAqa2b39 k2ZFl+jRYh351bsW01KG3XREtibmRTL62dLWRG5EIcLl5PbSxvsIz1FyggKiw1NfttjHNlXOX50j yBft6ChWjjfrOdma0tFw9xGRltk0M9uaQATcchsRTUJlUV9TgmYg46SNJ034kEQ0aYjwhizcfjYO Ea8Rh6Yh8uscaJPXVP2QhKgcMYGQ4lBFXaKWTYjMaIe7j5gDQdma0lGGafpTR7Tuam85j7amdIR9 I5vWMfrZWfRoKUQuW1N2+toJsr9MtiYRvf6iIRqxA2EjirYmzxE47HaOjogIzlFxguL0anKff9A4 terRYkQHhkPmZ9NyqS5mReVPg4rKHvOg52iJ+hoRTe7ZdXjXMrt+fYl4jTg0LRSFKkSvODv4jUi8 a4ToNJE8vRMRMxF1MrcPIzoFIWOlZbRi/ggFdSco6AiWruyvFosHaje91FE93FejMdgxRS1bIcLt QvbVYiZC7cvWiDATUXHC6hK0myvI1gSiBN7IyMw02FWPlkKETMw2CEeDJ2KmRiKqGK9l3lGndtML Qckv4ai8C3oPMEVbI6JJu7OXuyFpT41FT2RrxKFpzBXT6WhRc4XKQxKiYmupPCNTTNZhWSw7QcHW cJreXpEYHOMgXHeC4iuS3NtPaZ99Z0dbUzqCON/aYV1Mc+lI9PkrRBWebHvX4iuyX9poaxLR63sb Im5jFHtFBSLLqsCdXb4SW7/wIRUidEZ7/yoU+Al+SKkj5K0Z7avHNHQfIl5TgpBtyE52tLXdOEC2 pnIjWF9rXBbraqaGODR3AgH8I+OHpEZvkRshRKetJQwhKnK8fvxgaxGRCcL2/MquHzZ7dScoxv1g tKeOiKveMhVsa0pH2eloraijIeI1hagAIdfoX0cssHTVN6IQZfSzm2gbmiIPqRBBo8hGFBOa+2ST rQlEBYoH3RYykY5EfY0RXQ1vT0QNhzW+EQkfUgkaw13+k1YVCC7WSkSTdo1g7aiJd22IPn/i0DSv FtjPjCiA6B2UD0mIzPXDLo3CZAp21NnWKDcSrN9Y9KhHS/SNsI4srHZfbca431pb2NZU3I+Z0Y4U vw8dTebRkl8NOOoM0UEe21DvmvhqDRsrG08e7BEGsjV1jjA6MkoesjURrylEZTpEFPdbaMq2JhC1 5N61Izag7K9GtqaoVPzJ5lVOU9SyFdFkBUGj7iXCAZHoh2RWz/NA+hsyUZlevWuEyGxtOROhhjhp a4SoHM7RMmqnOFGHRJPdCYoX23TnyM3lXjoStWylI9cS0zGb+NDREPGaQjQxyjZC9+hDDpHzV4jA jbmJIIWtyXMEnb5ma7F02Lt416SOsjvZiwcqha1JRN5jo3Bd2hoLskwEWH/di7tYR2RrIvCD7vf9 rsVmr676IZlD08jvnFfL7WdL9EMSopJ9i55gY5QzNYTIEpqe+LbG4BjJFLoTFDPswYeM2ZoudkJJ HXWsQjRc6vnxuo/I1lS47r9ajY5WV7OiChGayIloMCmHiNeUjo7lrJ9qkDI3IhH5d23EB3J7bGRr AtE8/LsWi+JDzdQoQT05rzZRUXyJeI2JJvPXANaqoZi9DpEbYQ7N80Bi+rDuCo8ThASB94jM1uDO Nl6/2A6LozDZCXK2lnFF7s4fxatWztSwjsp527uv1iIpx7BEVLQ11lH5Spj26byoxACSramvhtyH +2THc/Qhcv7qq8H1c92QsUtD8PlLREgNPprgQBDcPhLR9PcRWf8Ue2okouw9f2IckHlIqWyfGc08 CCd6j5lo0lqr4KUdX5NjWsGBwByaBcl89p398eEFTbETihGdYRYQA9iBzNEZlfNrhMiMFtfLnA9k /PztEH0jSkfIyDQmr3C2kSu2NaEj+Ht7fDEWxXf2mGxNIII2MUOUYoFF+pASEXb6dqZS0bamdARU c8MtG/pGJHqPFSK3OKnjkphvRKKWrRCB02jZmhJHYfoUc9ksqDjeGiMJouXkXdma6EDAafrReQuD aZ9tTcxCFKxCrK+DWhmG4NEiRMVaGV5/zZT98eEFKc46RmRGi701IjqSuRGlI2gU2TqKB7KrWVGl I5ie34O5MTG+yabI1lQnCyRZTkS0C7pPZWtqpgY9f6NoIa9W1Nc0YSnk2M4nO3r+W0dkayJ/BHtk 92geNcR1wYGgdISTmSciKop3Nb/Ggk63Bjt9B3K8futI1NeYaLJgqdgQOV/0tpbNHJqn9WMa2qhZ Y7ZGcIwzomJPtpun5b4RsTuDEZV6vj/O1oiNsSURr7GOrC7v3n4a85A+pNJRwwfSOIOCsi0zRbam vlrFvpHxNSh7PEUeUiHCSahx4OzgA1ETHAgKEbTAbB3FhGZfos9fIUooyHJ30dbU/Jr6agU9/8Vd 9V1x+yhBCS+2g8mBxxB5SCaatAMJn38xF6t815hDs55KgXhtfc34+ccQfCOEqLjpwD0FHYdO1U4o RmSC8O23IfgfjLY7QfGrwcV26si92JeORJ+/0lHxQ16FwvUhuH0UPShuhTFEbGsiXlOI3PDywmP1 QKRyIwrRXO5kU3s+1mmLExTnaXHodG2XMehI5CEVIpjDNz97cA1S2Zr6aUgzO3fAGHTE9bUmeUYx pl3cEdUF30hjDs3mc/6nIMqxLY7XGJGlNDANPZDD7ONhItx7zIhKoFE7bS1mRpWtCR2V3TgJOhqx G3rXjoKtCR3Vr7XcyV4ywx5sTSLKh7shM9fXeH5NInJTPrZ3nfwj5oeUiA5YVGKIOIL8IFuTiJD2 ethGHnpFeCeURFSwUrO497gLvhEhqHq64sXztLu6TramAj/s85+bdT8gYh+yaVZPF0FSJgIJlO8R lbSN8inIqFlpfo3nshlRCQSBY3NLBUHcDyl1VPE5Wl+D4zXedSh1hIQT40C5Dx0N7j2WiAYww9sr EvOQqpYtEVWcXp2idmSVGrI1gQi3L56IOuWPBuchJaJRnMd28Dni3IhGtMJ9RIg4XhOCXOfSRYFB fSPc59+YaLL67LFbV/tANNW7RjGtbd0AEzndGiJQhsDvHlGpyONoJlJjW7Xav8aIinWyOEHk1dp0 K9ua0FH1bz9XRSfzjWgdeVtLkUF3eyNkawIR7mCxc0S9fmInlETUpntpuXgg3zVFyoETLEaf/sM5 Kk5QRORjkcaE7hyvCURtz4ICohTv7D29SrYmBHWfh1zUpbE4D9kU0SROiw3j0YpOROJ+yMYcmm1/ 3ieiiSN/l6CdPY62RohKwYH+zVgZY1o1K8qITkG1uvxRJ+KSxbkRqaPZneffqY0xiXeNddRdS4zZ WsyNbFrHaGsKUV/uZNO8iDUjk62przanuyFzFDQP7hu50RFcI/PLfbTnyY62phCNw9la4YWAwtYk hepwOqIc2ziYb0QruztEB80dwYbKbxNJ1z9BUHZD7592QUYdGanmt6B0K6i4wtwpKNGYR4Vd0N+I Mgmqm9kSBaWIqFWur7Gg5ja/209L0fVrkGF/pn2koIqCDkoftiFGGJQg4BU1QbTOoU3W0RSC2nCI Emdr0gd//h4FDccq/JkSb4PttZGgHfg4QUaXDj8ttdM/ih0IjZW9FekEpYqER5/JtB0vtj74pzEf W0Jf71rr9xEFLT6QPOTVMBr+rAd3+9izEgUJo3WFkJ32ia/IPFhHyU6J11GxpYTj+a+1++H1zwef /67Wt6Os43Snaj16+cd/+OPP/7///Pc//9e//vm//o//4y//z1/+9evv//r3f4//xnH+6b3a/0yj Hfg/zz/lyKn8Q6rlfOR6ym38w3EevvN/9XH8e4CJf/7b3/7+p3/5+PiHv/6XP/2nn/7vfvv//9/0 zz/+X3/523/757//7eP//C//8h8+HqfhH//0z//5P/41fe7/kT8+//kvfz2t/P/+07/+05//kynr 4/Ov2+7/6Z8ef+Gf7Pjgv//Hv/z1L//yn//MDzk9Cdf/JkQB5yW0XZxwf7ZyIxC9p2+BQGh9CRwu DX8JfL1+2QlkhLbmyQm0gdV4w09oVvsdYcPaiQl0Cb4Hwtdo2L3rcT39DSdE9v/F6bRFX8a2KH8j HO6vu8fsITBlJ/BAAvRvgdA04hHiT/5G2LGCYQiHq0RsgXXcIHQsON8IsY5pCP0ihQshl7buz6Hb Lbm/MrdtFs4p3n/lgoBMYKaWe6PI/xZYnUB9DlMQOONXnhCv/o6wxoNdmL6pvshJ7h3Oy3PsfkXb 6T6cHyWaXgN2ge7+ujrY6Mc+zmG8HCq0UnuE+JO/EY7pvnLB/vonwnqDUB3sTOeQx4XXK4r8Dv5+ OIcjfBTvuz+PjRQoz2GP55Ai7wF7ELoTKM8h9o6bwLSi6U3gavsN4djdFU6gj5+vNOxrt9b9sflG ePgLtoQJtVj5au6v88E+Q0WMw8//wPRB5/WV7xDyTz4Rtmgp9KbcI+SDXT1TsiEsAiHPLt2fQ/fI 2Uc5VgxrkY3XC5S3TQ4CfYr82fkR0m13CLunrdqmt+LB7hYLhkTgHcJ+/v3iBeYVbdkCyd8RXnHr /PJz2ql7V+K6bRLT2nHY+0IY7sODptO7oEjmn/xE2J0tnwhr/Cj3CKUOuzO9I8y+bITl1XNwb3qv cxidJX6XYZHDvaW8zuGHF+gba5/34UPgb57D8KkME9jpgu395Yr8hvC8YNfwAh3T1+OCfVXcvhHy sXmkPRIy657/PkM2eCMED7b4v04HO1mzDWZhMu7++UZ49BuE+JOfCGFAZSNcmd7llW4Q8sFOjlRo X7A+Kfesfz0u2N9evbmbN0BgCsWC57ssBcpzWMKrV7nLqzTybX46h0Fgo00lWF/9DWGoPW2Elb5y SuTBimTblTVbyF/6YYSWsOnpG+Es7MFS0u37P3F+Qzw2K/CPXqb3cYPQ/eRvhBmPja1qpUeqww5D j1Ac7Ow2e+80IzlLFqx9R1Lfgc8P57AFd65QFIAc0F6gjEadb7PvQ7pg26t4+ZulDM8kvo8Nd6+O V1jxG8IVo4DzJ5NLvB3OFBByrvaiVhpY1DhPRaSuu57RF8Lk/ro82Lil6Fo9RQfbbhuJ0IW3T4QQ lxjC0ugctnKDUB7sjhesIczxK++W4sdDf18TeJ1D9+oVHMT6FgjrZ+9T+pfA9jXQLrZvM+IF2zpn Re6jgNHc9VWQsuohEBmc75/R58FOTuARtoleAgf95Dv/cMR4uSMhwkPgHhcJAu/e5YFtMddPzkRb 2+Y7b8q3f7h6QOiHq696C6cI7hAuT+25A/BKJaVR3jg2139i7TZPEDj3msGAMPE5vH1TTOVQzksN iVy+EXaO9W69r3w62d63qQf95N5J4C3C4vahfuZDvMv7Tfn12Dz+E80R956XyFfmZzTx5XB7H3bH dPeZ894g7AWaRxrjlFuEw8UVhnCyjy24q364sfH++8wdh7+/ERY2vds35XD5vs8ykWP7IdD4caNA Lt89BFbHzvVZBjarfP/kxlHAT68euiIl9oQ8Hc4g8A6hFQczPqNmOVGHc/E55I9y/SdKQq6bD2PL LTkKbJl1yJXLS2At7iOYwMnF2WORf3iHsFbXIHgtTCTTK5OTujcIbZG0mz6w9dDkfc13js31n+gF yQfsf3sIHszCztKdwNVwysq8r87L2GcS5eS768t48TAabef1RZdDeauG/305ZPBF7HLwY+nPG/tX hOt6ByfSSJ8C3R6Yb4TiXb4VWHci6iXwwJ3L3wJFH81iH/v7J+M2y71XmKiue2KEtwJto+iHE3jQ E9DSOzp8ucTTu8R+U9HHd0/krzp8vSlIp2kfhfPYx1sIH6SPyPK7W+byoDelsCtyJ9DOIc7I2Xxi Jg8W5toP/9flI4VplvOR6pSQ3AOF5HDeCOy7WvISmPe2qCAwi4Ye/snXYF/+OtyrVzdvQ9Rhf0eH 11zegoaTj90T0ynt3MTlkGis76lDXG2zdUiWMsS7fCuw48qTfQ4THZsh7kPhilw6rEiCuM/hwQLL O8/oQ6C1VsL1VVTFR3Vb8U9+PPTZrQW2hz6J5k1GeCcwG0mCD2/5xm6Ze534J+drGel5XQEiOzb+ stkI8zse7EOgm3d8CKQAvLItZ96Ne+nQTfSePzmFV/TjuysrIrwReJ47zIx/Wm9W59uG3xTxky+E 9evAR+p0nipbynznHL482IXncODQzrcOm+jVZIF7QL74PdeGcDZyOBvfNncCT0+hFzyHS7QlGNkh IaSB/acOMeD+LOurkvdlqXJCeCMwe6K2HVZwmqW9YyllL6Q220Uf+/RoOxX951pv6PASmLu3lM19 Rzd24k7KwhvbXzrEn7xc/PxAONi3uROY/aO0zyHV6HtjW2aX+FrwsZkw4G/bbigufzS2lDuB51ft 6NvYOAkXFw7+ymrhyA4rimsj2LxIxD87RUR/J/A8NihgN4JThrPNd7pTLxInY8rAZFp3w9NPhPyV 7wTWw80k74XvXCgU3pcglbp02HC13UVUQSmCKTKcdwKr3/u3x9aoTWsXuX7v8P1GiPm+veqQEkGb jPNXHT7j5cN9ZUeH+9Qh+zZC4F47ZXu38W/bgjjq7tuLS35HuAWeCAcm04yGhHNf4tVrYp/WQ4dA H3hNgbhffL3L4hzeCKzhXbZVdpXOYWLvS/zkTS1oWRBEaIsI6V22mYg3dLgF1jD5YPsEOLMk2vqb 4JV86LBBfLznn2g1nfJt7gRWW0yPH+UIhDyXDjN7sJRmWVcodCScP/lMZ7zbIkP4VBH9jcDZ9mzQ S+BxRo+0GbywLS8Oza7/xFEdDUWyJATR/U2O9e4ErhCanW4DsxoZ3/YbOrzc+MNPAqZ8hOhx+zYi CrgROIfbPrJ1OOO046z8piwOzR46HOejAjMd+XpCgg7ZP7wTOJcvFJoOeVeeiFPEKMXjf1OQxPH8 94b7eC6BS6T77gTOFc9hE3uYqsiKCIGnt/SZdhjwmmROIQ9t/6u93/0dhCZwJR+NWv6w8kyrsuWN R+qwwfoBQ0h832uJis+NwGXhrEuZKq69+tbAjDUenjpsX6XiV157+tvrsIrM0o3A1d2Fun9yiZz7 yApwuL+udOhWdmyByS9cPREe/KbcCVx22+HfPk2RXr29w3Fn/VYpdax6Bg49zz9mhf6/+PPf//y3 P//p7/+u4z+/zP/k0coB8z/N5n9azn/M//yv+BPnf+w0iPGftP+Z/RCQjfvY/z1M/+x/fQ7/hFvj gH/6fCWSde/+ML+SJG0mvp/EuVaX9YVFEWsFSCSOvdCE//TocL9potnnU9z5P34S59CdcIC2wMTF qcwF6wmTEBfRAYO2tb5Fdp8l4vFbdAuX+Ox/jdthlsoKwT8DuuR1R2tLlkol4j89ugR76+zHRrYv fPGzEBd1B0tVTFykM1tA9/oGOpjU3jWM6Bcv0VpV4J907tyPzfGtX5M/BYqL6Ko7d0SRvSCuKL+h mxg92r+GjW1pU+l+NxH8is7EeauICdi12Nus8M+AbnhxiT7F4CAKxQV0Y/orIFLVLrUO6g7dcDxq 1gkUPeEFDbpvoJvFnbsjkuirg9Lgn0F3uNbLpLt0fTgoSlzUHYyz24eOG4vRKpoQF9C5C2pudgbW XXsb3czuGIe34tifilqo4J9RdzWg82MGpzvNxxjFRd01p7vmz533zrsQ5/LgaUcH8K+tRGc/vXrh 30EH623sGNOznTiGHfDPqLvhb5QSxR187lAc2axDF5o0Dd3rrRhCnNPdxZGJ/9rifXe8JmHfQLfw rZiuxP9Axwdlwj99tRIb4XZTRExRq/sOxbnu41McEKuZuEisZueQ8ifwz4jO99EQSadKdqC4iO7w 6MhmIdudhLiADslNTFzkRl6D6wU/oIMi9qW7eBuLXHw64J8e3YIVGSaOn22V5Hj9M+pu1p/FAbos xMUvG5px4u62BWSn76AL4iLnpTp3O2vz/c947rzuYvb4N3Gku+HERZ55/BRFiIs3CtAgZquJRN94 ZPKgfkIXjCwS2aCP8hSX8Z8OHWz0MnQ9EsctUWJHcQ6d1WoTiitxP88SJKR36PazDT/2CF1lJi5N nn+8Q5e/KnCJmc3RjaKqAgX+GXQ3w5eNn2IImwVxQXcdAoGcQiF8i/sgD+oOnT2MEPWc0jPZbK7k Qd2iy26Bm+kuMsJLI6vwz2AVxfkoROxkqfefxAXdje7PXaQs3pd78KBu0RVcAn9dnxTiVfKgbtHl 3QgIunMMHneu9j6b3/8MugvnLjK0LtEwgeKi7mB5qYmLq0Lx3A0hLr5k8xcfBYj6f0WX3T7k/U4S OlFB6fDP8GW9U9Eo8WEXVBgS+kkc+MbWpcU/VlwBWxBHjLu2kVEcjgZ/bHex5Bt0Qpw9Du6+mz3W JcQA0zXawgMuubhlkDk2vG7d8bTRrTjX9mLdWURZu0T17jGqxD/2cFyqdn3GjW4LKJnrb+JO3QPJ 5wm2sm/M7+zVtc6967ljXcymM0bcFrBqoqGgO3HlvM2xidToa+LT028nyfgY25Zx+LGdSTa3uyjR CXFrE3gAWNrVsYaoHD+6hGNPUqnOXdzL3z9QXNo7RtgLuBE33I7lYnvN6CW761QXx3jtEWH4saG0 9jjGEh2Ls3Y14Bc8/zXs8DCbvevK5K69egb/cAVUq0R+RHGFhoDuxNlCB8jy7BUoVIvlc3cJEsd4 um3ntYb5mt36x7wCd+KMBxVYkG1rgLdZnZZ5tLVQ/4xtKMeuOuN4CsG7gY/DP3fi0rGA4nH/6+HJ 0GTi41sQjdckXFhrk0DEir5Gv0HH4uZxXr8vcdO6ykl3dzVsPijLliDDX049jNNaJ4WYkL4Rl3qG jcafaeTAWXbskcMbkrfr/+06RXE4breMUtNDvaN442qKvRXZ5QKCM2tJ8he6IE5F27Cv94pHKUz5 +FFc9D4hq20uS2wMWoNn2B5XE+uun/6he7briBdU6USZgOL8BLwrf1irQ4rnLvMelW/eD0JXdjsz iGt0G4/2o7j4ZVt34tipGESm9biaWHcDWT/2vx7hRtlG9vBRihDn0J1PDw67rMB68u3fFSmOdTfd AplspSOKZ8uP4hw6lxXf4uI+mn1B6WebdFdsGB0exh43rjwys5RamFJ3598Hm7d/rZSZPQSB1iWO dFdOM4BOr1McLSZesFhGiXPoWkTXOBfQiLTocXGS7poLwvb2W4/ucVAeVtGEuLhm7jU0v8X59WAP cU2KI91Zgz1srdsLtWMgsNqP4sJ6RxiN2XuV4wqDJUgEHw8j6W57AbDsoW7en/BjG9HsoDhENwpy CFp775Dljy7Fke5s5yQuNTjdxbg8bK3yoziHrruCqomjK2AVJoe52sxId6u6FcLrDDPoGM/M1DAg zlVTbPdHfXlQtrxtBS9gTebCebSLRnT29199Cp9pWod+4Lte/UdxvtZjUxMfKH168p7zy3Lj4yM8 5rxxw+WNOzzOdN+JvoA7cRUHJPa/cj8KtxRel7sQZ8078DDaBhzPfie7ZX4QhxcUvxWP21gOTLO4 vQjxhc52kFJaZqnm6ltxC9aPFVe++EYnWlqvEI/FuX3D9q+FG1rvhmilOJzYN3GU5VHodie5EOfI JO1fAxVR2ktv9RCyFFcw2ramLerlEcT7u0ebxdnMCizdNMoHbg0S6O7FwZqsLX1R1MO6u6Y0hbiJ JP72r2FDtS73/iCuQbm3GsnIRxAnxnMeg3UkznaxLvdszxk9dxEe/yAuvLOhIvAQJwcBWdwZzw7I Ljbb8RfFidHyn8TBQWkTN3U/xIkm7838oMQVzLDZv4ZdLY+DEtHdicsuy9OVF/DBIzmP+UEWZ57/ 66DsrU3KgzreFoc59724j/pR7ob/WJxtM8e1awMb+r/RcZL8B3HrcOIWV0D53PWqD4pNzrx8HPvX RD6KaIX8QdyABaPLFmerHFRAZwvHlbhkBH3PX3v+aw1cwjqVeivOclDPtoUtznHhfeeNA7rdGabE lQO8kj1NkpDs6qYSdS+ufuEwyvmvrons7q3YDpkQdyq/Hq8fu8oX9X0qSpIfxb28z1U3450TNyUh yaHFnWbxjI/Pfx2eCOLm3N2LG+enaCi99phdFGQk7bxTlUNmtBJYOrJs4xu6+0Fcre5fm+eHlvdd Ms5W6cyi+7n/dcRzp7yAH8QdTx/qErfEudv31FGPcjo7q682/vcZZrGW/X/n9S8/z3+cLu44YP9L Lnv+o44/5j/+V/zh+Y931r9cox5u78v+17/97W9/4VrA8RENy/YbIhXDV0YSFDN68e5fYlw2zK17 3mLC3aE67SSajGIaur93BQ6Jxovp8ep5iUlOTEAznRgX3n+PXcYLUaBBZdi/znjrs4p5RqLt/9zz r1Vc3nmrYp6NqPveBTG9xS/1clb83IYLfBxn5qeRzfovZUyEN/MaXjfI7Vl8infXjET3g0AzcJtd KHjsGqVgMBW6GbDgb4tJQQx3FSo0xTELYTXm9S6X39CYbqoX41+8vTQpBgyEpm0Tfv61uFTh2EvI tRiXs3XFSxNzRDGvZJKfuwhfCrlkuicZ+UYj5y2iTcFfq7vTA8VskvEYrijd4Cnu5yn2/t1ogiRB 6SY5MQ17Mz4f+wYP+OsSTcVGT5O6mnf8N9mTnKeIunEWvpo/fpKKVukGysF7u8eHEzME1QrPJjRH MGxiatBNfqUM/NxEsCn8Uc1Pw23T/LiZl/C6Kf6Du7rtpxGm8rnhGYTqZqzsRwU0XZwbnj2ofpvn 2CVtJ6a+zo2fiwh3MbYaWRo5uMYfHzfzEEE30ON9oknVn5va7+Yg/LlBuqlTjKPA+XxQfEsx/txg P7ztK50piBFsmgKNa+AYzsG4Q8OzBM31lm0xH0FMJo+C0XQXy29KdfS+HhShMYWudON2GBz+/nkQ MlLQrHQD52Z+HfCbNhrVtnn8qpu1ahDTyaNgNKYbt0e4hfxYh91sb6NZnl3SdCO67ngmoHn26OG2 JV8/SqiYZgGaI6o1MTncxWORR8FoTt2gY7L3xywU02Bf2E9o/H6506TBa9vnRvQ4UwNcw9oyb6a6 dhNqMeFLwXW3F7qEc1N5zxGj6V8H8toal1xwTCZ7FIxmnN6WRxN+1OxCN4V1g22ee6lMvNLvxheC btBNmr4bIIgJcwZeN/hqpuReGPvgp6Oq5wvc6pSw4/lw9Hp3P4qb/07duHPTUzAGwS3Avfompjox Hx+3YsIcgbepw903K4Xjl/rN/EDUjeP7cY25n3rnBvfkV7f1xX5U8CjarZjgUaAu5ukW+WurQf9i mBNwusmOuCHtnWMoBhba3KPp2GRs/4VTGf74qQ9Ozcrjq4BD82lcA9HC6908gP9RzV+i1X/wpmJN um+mv7Ys3Z+9MRzcusJixtdE/8ayr4fTTRHzJopxHVcp2kB7Gs6jsP/Tm65wFNMwLtuDA8E0q3ju mDP6/FQwTGtN69U5Jnvt2k0XOGbKv+br9d+Mpsk9d6O+w4dqvYBYOrZ17v741XrTuRya28eAsud0 aw0/ry2Hdz3BIKa4joe1/AE4P3i57wWGS7QjK/Bn2lz4GcRY8V4XTNwpHm5uL42CVC/fF4Xs/fUf fOw9St/KMzILOACPtXi659cZwwjr68pyX6rn8cY657E3u77EpDNm9aaZ+11TrkMDH2q/DC1kBfpd b69H05AzcVGQOBp/cL4o1hmT4iU6kaLn+aVkL69bS+rSAJuTHBdaWfHntunW3X6l+NsPl9xt9/pO jEdT8L9uYpb/Ub3e9ez6a2thDaw4as/tXn/c9Oq6vrCCa4j3up3s4ylwr72YcBd7mzp/lBOzmfyl GL8gDP+eiZnF335JzefOIMbatqFUawt1pvvgq+S7blf8UbZ7A+7i4fblbRW3GzGBZgEyNoYGmz0+ H8t1dbOsb+LFjpbutzvblzJnXzbJhubdBF3exiw8nG7URlT9wEDbRB07lY9oMu9BZTQ2Uwin+Hyn SnPXVqs8sydfhoZEQDYj5o5frf2mCda517aTAkr8OWFydaeBbrtVw3P3/I+fBn9eW94TtaS4FuO+ 1CkGWWaOtDlSQUxed82uzjTPL/6kWLH/ArZB7HNTb5pc/f7DBQvYzv+vdF7iC8TMo9x1o+Il6lal nBaeHD3CsVmItBh3icb7xpgAlhNT+aKg585z2dhDcfh3yprGfl9g3HEkZi+WC90Im6c6XhTK2ceM yfJLqT8fa2zDA6MeX+QO2SmykPcrLz6x7sR43fTDpchm9qd4Tzb339D088eDV75EGujFP+3Xb4aY YXo3KfjF+9p6nJt7x8QCIXzDDzeEZ8ZgSanHO/XTl1rDB4m9ubvY1vR9f/DixIQvBQM7+xGNaF4v w71uzmeqeN2sw/t+5dV33m7F9BDdJb+QwjImbFOZkpnD62JhBHEdv8m0YpmSmTZa6s7NDBmTfYqD TSk0bsXE2pVDLyaTTSk0bstCOpDE6vrgjWxKoXHJhLUHSB2ansimFBrck7FPsY/DzeSiTTEax2K2 /WIsz9sDAwMGyYnxaLDL2Y5fqi4Ob3OQTclzg6GGWbj3/boNFASbUmick5YPzwd/bLLiaFNKN9lt +EqOFWO/4WxT6kdN907lTcSOPyoJmyL3evplhMkWpzhPdDZO9GaRsKvLi3HrUh5ook0RGku0fDgx riHi2OOrZFOE5rQpzGWZQxHTh8KmpG78lZ59onfTtkebEmh8T0mKhSXcsDScmJAicwxI+Sv728+m tMmmBBpsat58EcE0S2WbEmhyQdNce7kriLEJI7IpgQY3B200w903pS62KYHGDVlnvy/DxPTONqWO HyyD2gyCPpwvhSct91eIpukKS9cSGhAzMifsLjE+nMdd03ujpI+njDyRbIrQWFbAexQpvAxV2BSh sfWT3qNwS0eP7e+STSnd+AH5zcmIaNJgmyI0nqXYxMzpTNMiCLIphQZTG8YP78VYazHZlPhSxelm 4QqJbQxGyBxtSn0prBwaI5E/N1agJpsSuklON8uvDLJYM7NNEZrl0z75WgPkxIh3SohxD4ploUvz YrjFSSwnt1gDUvK2r+EDxVjTd7QplSLDyaS9ldWj2RWhYFMyYee89Oaak3bNd5ExyB+VkBnc+v79 jxpsDDLv5wpLVoTzzj4sahxOjP9SSAu3HZPwwVslY1BoEr6S+foVIKYsfmAUmhHODQ6p7h/1QcbA aLDD/XGKffbaSsnRGBSaPv3LgB1XOw2UyBjUuUm4eSofrq3j28KjMVA8tfyuJDvFISwDh/ZwYkJO dALdm+V9/XM3BRMAo0l5c+k8/7X7FP3juYvZa0JznuIVTLM7MQ2oSboTE3VTnZgVYk1TcbQp1o0t CYOKUI/V+QmTYMOJCWjcSmRrI/Tn5shsU4wmIUnYdkymsym7fsimBJrU/ZVevRibjCObUucG+cJt RiagWRwIiXNjfDFQHjV2Bl9JXINtSomBX7VN0z++XdBjVIqn/ITZ/uA+uptdcJZTkJgO/M/vPbrL m2ZjmxJo0ianef7rcCyWn4+l0sGmBJqEk2RmDNMnF8wziDYl0JTd3A8/avgWp2lpoGBTWjcwT36K mb5zoVd22jQaGDXMNQaJ1kYabeoGDdjUGTMMh8YS9tGmJJqKfKNpb4LGHwUeRXFi4l2MhaXsGtP3 j6pkUxJNQjRlB1AopheyKSHmwKdgm2Z3xlAnV8uqqt0hY6d98BqOH79TVdXucPjd/JvudGPMJGRT jCbh6MFeE+7f8L74nRJo0qa3RTEhLIPnrjsxQTd9emOYIbrjhJ3WDa6C6PGBMUshm5JoOlzpzXdO HZtAmGxK6aYc7mUI7e27dhdtitEYWYx7GYYPhJpIgks0eNsZGv/Bm0jYad0g50f+CnMwxldCNqXE FM+Ge/iwrEF7+1M3FE+ltvkAnv86/ATTsY8R2RQFiWYMyZ3i5lOrGE/9gCbhcg8Ts3wA3QcXljQa NIbmk5tmU+z7ad1Aw1Uau+iCummNbUqhwXUD9txld/sNmGQfTkxEgwm7utubUTeJC0sSzTHc8Zvh nZocTwk0GWfbtjGM4Bd3tilGc57i6k7xDGFZ/WCbUmgc55o9oiGAFu+UOn7opXv6/7tibeM4POOU t7VVhNxWn8y23ijWtMICJuzcns6rIsTFWoEmIcmGiekhuqtcWBJo0m5EforpMdWxV20Hm5K6aQks fEZj6J19P6kbaL7dDm147komm9JfCtp4zndq+murTs5RSDTJ7zpowU1KnLCTXwpYuffL4FOrLfM7 JdEc0xlDbFNOnKPQuvG7NFawqfxBNiXFHJ43cyQv5uAcRVNhWS7u3KzD+34fnLBrKvIFPod9pYfh nsYNVwKNY8bfFj69mCxsSsbh/hTjxNw2hs42JXWD+Zv1FecZJjdASDQ9OTQ9vOGN834Cjd2arjE4 tGOYaZBNKTTNryMJnQvWcUk2pdBg660Rm0Zj4CS4QJNxCmz3Xvv2L3t+yKZkbgv6tuwN99cW6qbd i0k4lnHRq4Zrq5FNdQ7LzMLBaVu+6vpoxwg21TnWLPho75ZK31COwz0/ooEe3m1TobCUCtmUQGM2 hX1bp2PiS8eVcxRaN1gg8P0Yn48BlmBTAs15UFwX2X60Qcw8EtnUzZeCS9RM02faGtuU/FJ4UWTP M7S9LX6nbtAMFNNjt3Mjm5JoWnZikv9SdvCjTQk0HXPyJmaGS7Q2sikhxmbw3as5RzAGnnQT/cXD 7QCw2p0/xVPMzstu5+r3AGZ/FxvRGdmUChKhhfdauOd9v8XvlOx2Rq4wezV9anWjiTYldePrmtmX uWxhFNmU0o3z/Sa6O1eqg5uKJJqE3pZFvj7WLJz3k2iO6U7xwnnxh9MWbYrR9K/kTfPwSandJR9t itE01Onukvf1cCNPIJuSaA7nFx/BS6+VbUolXtKAa6vidrZLN5yj6ByW9c2b8hRzIB3u/uBL2BTH mvX0iyAJPnfDDYrpXKwVaDISlm1vq7MLGW1KRb4L4nA7xclbeP5gm1K6SR7N8u1fe7gn2pTSTe/u vlnhvhncVKTRQJCYz2srJKUG16cEmjNIwE0AzfPhPM5NtClGUz3tfKPMvmiAkLqBZsgdJHpjaKIB QqBpGM7tVTahGe0QNqV+VPOmOX2HHc7Of+tmcFjWzw8OnmhymyC208a59MGxphHgQFZg7Vox/qjB TUUCTd6f9InGtr+EoTC2KYEmY4fVVeTnCCbYlNYNHr8jTnNNmB79AU3B87ZdyPD4Dq5PSTQwErn3 AfhGPSPOijal0WDe75R6hBwFv1MCTcPW773j6AXmqrJyjkKgqftdBDG4r+LTD73/oBt77lysWfyr 2UTzqxATim6npcbBbmFTHJZ1XJx9teL6QKjyOzU41qzYKbPPjfcoDBzZFKOp2Bm8O6X8FOBIXJ8S aHxqdVs4B4nRpqRusr9vwsBc5+ZXgaYhk8T+Ub50PDrn/TQaYJg2onT/ato1QjalvlTCVW4NJ43u 4qkbNM4YaghZD+6jkGiANuzaRuab0UQ8JdAMXAy2bSrki1tmm1I/Cmegzffz85rbhQw2NTkssxY7 Xw/3HoW9ftGmporDB/L2nw9MHPtcZFMCTcU9YtsT9aapar4STYbjlzzv6ueDtivYlNYNdi4kfNIv 3XDeT6BprhcyXylZRFO4N0mgGciOYO/U8u51P9impG4Krm3qewQbxNie82hTEo3rPuyOGHKfYu6j EGjOUwwpMkPjPYom8n4CTd8TCyCm+yR4z+z7yeNXphMT+tJb5XhqqugOW+H8Zqvrg/Mw4VSxZsfj d503FCNy6QJNcfT81sTo+/2syk42xWiq/+AHvsVXfUrYlNINDujyWMQQQxpSN9i3ZboJj28XNqXR wI9a8UsZBTzZlEKTMEU2Ts8giOF+P4Gm+UBo4L1xeVvs++lzk5zTFs7Nng+PNqV08/pbG830NZg2 2feTP2pAbst0E9h4BufSJ4dlY89APsX4jRqfDz6KaFM6DncdL7W6U4zzmj+gKcjisxs8Q+ghhgkF mrJJPZ5iDtwKF1Md3YkJuhn4alqi3983g3uTpG5gRcF+7kK/32LfT6Dp+7b9/lfbARv7bziXrtFg +nDGfj+Vo9BosI9iIB3O9WpmtilG07x/Y55BaNRj30+gaX6Z8HRbpz8flB/RpmSrClq4W8By6Yb7 /ZaKfBM+vs5repZHg00tjjUHrqa145f8bJnN/Uab0miwrJ5jL6Q1MkSbEmgKMsjaKR6R/4bjKY3G s6oU7/vthqtgU1I3JTnTTN6m9gx0sCmJ5oAOO9stHOLwxINPAk3HvmQ7N8nffjucDzYl0RTM+819 hzsxbFNSNwmK/Kdpxk5w0Uch0JwRc3M2lX0zWl9cnxJipqvB2HMXBrsH+36LwrLtXrlzM71fPAfX fBfHmj129DbfHKJ8P0Zj941vRhu+4QqdtuzERG8rWHjICoh4SuoGd3Zlv+hk16c625TWjUMTAmik phpOTECDkyblcDSVnw+etmhTCk2bLtWRfEevdVmQTfGXsryPi+6q7xPFnrbixASKoYmugM1ThWLt YJtSaBKGrHOvVHW64T4KIaYjP8FGEzImozA5y3EwmgO6Vm35bmA5AKftcGLCfQMTc9tN8u71mFyf EmgaTr3vRcXBhYQkeHZiYuSLM0LZz1P59GF3YuKX+nj9NXvD/YjaEDYl0JznDXVTENxVAuRcuv5S kC8+36ns6Zf2pFuwKfml2uFcyKN5/8YimGBTAo3NqMGPWnE+fFc9gk3d6KagmNDRu0lSIzmL0g3e L+Vwuyg/H4zBwab0j4I1tOWgDju1Xti0GW+/43Dpw1CsndBjcjgx8S7Ovqsj5CgS59IZjdkU7Pzb 67F93q8IwiNGY+V4P07j3eudlCKbUrrx27nj/FQShEeMZrja3dZNyEIKwiPWjUtK2FrPw1cSN186 2ZRAg57odiFDSp5zFBJNhiR4OWIXmXUpsE0RmrmZ9EFM9/kbewzZpgjNdJXEYmmgMFnL8ZQQ4/iX tm5CxqR1YVOCshXFWFeHb8fYcTjZlKAJrN40Q2pVEUkINAO3TlztXx9OzMEslQLNaVPVBYlHD6bJ felSN/VwumktOLTc76d1s5xuQvuXrZlmm1JfCkrHpXh6lGMvWmCbIjTD7QMuNt7gfb8mSMQUmgz+ zSmmhG6gxLMeUjfNO7QzMKMdgkSM0GwvfaGY5Vtx++BZD/mjoE11W3iI7irn/RJRKO6IGe7i5rZV 213cBDEfUSjuGRFnDHN60xT1KUZjNnU4T9RRVT2yAtGmGE13k7XbaQuZNuH7Sd2ghdsWAHdubHyT bErppvje6+Ffhp2SjzbFaJLb8X6e4hm8rcn9fgLNcHm/ktwG8O/+m2hTjObqsAExOTwwnXtoBZqF 6SMT0zw7xmZTjjal0MB/fv8o71EYqxfZFB+/eV4wr7u42Aw0d/SSTXVGgy3cVubyX2oM4fttMUE3 C0PWtunaUYzIpTOaWJ1vbiPoTS5doBm+kG2Pr1fxFL6f1A3mi7vbubOTC8L3IzT2wbu7tmIJUOTS b9CAY1L8DpQb3099KdhyY2JqKHMpskv+UmuTCD3FZHqnRC5d6ibB8St5zzK6HzWFTQndJERTIjVV TyKekmJgsbKJiY+viKdyDMvO2w8Hu63HxPdRjCXeqSxiTXw1rTPTf/CROe/HaCy54E1zhsx+Fu8U o+mu2d66nUPTtOhL17r5eP01002wqcU1X4FmnR6se+7AwJ9veLQpRmP8XmBTlYbCPgSBrEKTscxV /e4cu4uZj0KicfFU8evQHhFMtClCsx+YhWKC76f6KMS5cb1wWzdBzBQ2pcQ499paB0K1TPh+WcSa y7djBFdA9ftdYoJumq+HQ0r0eu66sCkRa5bhxAyfPtwZWrIpkTE5ljPN6AqIXLrWDVagu1vd8/kg kiCbErpBnn37UWGSfwxhUwoNHr+2aSlBzP7gZFOkm/OBSe65C60qu7BENqXyN9Mdv+pLgA2Ih4sT E88NZtrKLnOAmE0IQDZFaIpLyZtNheLJB+fShZiEZM5bNzHxomyKorvmgsQ96eYeXztVejtNvG/Q NAfaxnX8uLAkNyLU5q707l1InJ/qTszPP6p5AhJrjWRjED+qdNcrkEK1TBAeCTTWC+ku0eKnK4wd hY2BdLNwW4mJif030hgITXHNaPZO+Vw6MocUJ8bpJjmefUMj1sqQMQg0BYPEGnlo97pFMgaRo4DU molZPpcuC0uFwjLbQQC334ikPlM06l1iom66M4YaAuglHhhCs1ucuhMTuMgKM78yGptlxMbgEdsx bF6XbErrxjWjzdgYLGyKdZORo9XEjHBRqMKSQoM5UHtgfDJzF92iTTEai/vhLrYGmHBuhE0xGrd0 YG9SCYsxVRJc6gbRtMh/07NIgis0C3PpVvP3l6hi/VdioNt162aFsEw8MIXiqYqbFXYh28fhlr9j m6Ig0Wh0Mopp4dUsImFHaKw1Dt7wHDjCvbeVnZiQXBjFG0Pw0gsTSWjdYL/f9LtILWGnbEroxuX9 ZiTI348v2RShKd5L73s7iftRwmn7DU0ZxPw6PoRNEZrzFGMSvLvloxsNN5QLNKdNLS8mnOJDJBcU GhgINzE9JF4OJhETYnxWoFgrLju00aYqBYl237hzEydrBYnYJSZ8qYJ1zRnZMUYV7xShsR6T0BwS AugmkguExpgjfN/WCKONSSQXlG4qPr4zblGz54ZsSulmZmdTyw8ijMYDuhoNPL7FJvnDPIN4pxiN pQ/Bprrf83HsHnqyKYkG+v3s+IWREUHKLHUDK1i2mLCbazAxn0BT9k7upxjXY/RMH0ab0sbg0MSM SRLF2krxVNuplee/BgJrI5BVNkVBYto9uyCmhqYimJ+6R2N5P+y9XjivGzNt2YmJ6UPfcJV9INSr SC4o3YzZUUwLuhkiYad0M3EGernF899vONmUQFNfDTdmUzkEiaqwpNBg6bjQG64a9QSaghTBJqYE p62IhB2jybuJCcS0+MCIYq1CA+wIJiZWWbNI2LGYhI0TWzeh6DbEusWqojtgqbTW/3AXdx56v8Q4 3RTHGmdlLn/fjCy2qBGa3WPiWlWO0MKduKGc0dhzByottJ2mAbdzd2LI23IWHuY1bY8U25TQTfdi QqJXFpYUGhynKQsrgs98MdmUQHNA8aQmv6f1wbVKNkVoMhKkfxbbnePdpDmETQk0CfybMqMnursP yaZE/gaWLNmPagHNUu+U+uBYgab58CZImTe7R0SzwPezro5A6nNwQ/klJt43vh0DmlafMUO0KUKz iZKcmBImlj6E70dokiMu2afYTwHuolu0KaUb3JFt940vARphOdmU0g0+vsV8xvCGi3dKoUl4pdsa 6FCQZFJmiWZmZ1MxnlKNegoNpsTMwn3Hy07YRZtiNAVf2y1mBWMQ75RCg4wzp5iwTrpn0QDBYjJy w2ybGsETFfGU2lmboJRjzSG+o3cMkaPgnbXFo7FAOAwiiLXAjMY9k7uLLKw/a+KdIjTcGLxCzKDe KakbuKYMTWgoH6KhXOlmYARjneDepsSQhkYD1bKaIv3SdkzIpkRWoAxnmsTxwkPvEg2q2F6G+vs7 Jc+Nf3zD6hRjAGGbIjQdU/nXj/LnRiwPkD9qDmfhLTRAZCaQTZ3CMstCgZiEd+q+i5d4pzrFmqdj AmNYhfYz7Ga0aFOM5rSpjw8U0w5n4V3VpxjN4biBzMJbEMOLo7RuvJjAKTWXsCmpG2zwPHUTZ+eF 76fQuI6XtQn9UIwa0pBoIGFXL+ZPEGMmxht0CY21f70+eKWLohdRrGU0FbeTGJrh6d5ksVahwQzt KSZW59WQBospuHRg6yY0209Rn+oUlnXH73cGQjWQzynfr1Os2b4yNL+aGH9RDEEixmg2w5ETU2KB gAlkBZrQ05Yo71eZmE/q5sCWg7wXajrdqK3USjfJq9i3VO7njmxKfSlcX5+ItLCIhnJGU51HURMy OVxvuPD9GE1DI7Lj145wpaut1EI3B/jFZgwxgGYiCY0muVdzhvqUyvspMXBPfdZCw4SLB3R3h2D8 Utg4c37w6S8Kc+HZpijWNGoqJ2aE8T1BIMtoNsFWRTEzGMMhfD9CY31byxtD6NlPouardfOBYoaf VpfxFOumnLema5xJ+Bg/mhjJphQayCbVjF2E8S5OTkz4UuBPm5gS1i2qvB+jaY7buYohDZFLZzRt bwjHHxUWxie16V2gSf5HhQmC7eyTTYkcBTYV1Yx8JJduRPProLCs+QGWguthruKJaCgfFGtWxyV/ iim+WjaKyFEwmhTF5Dh5ImyK0JhN/WjhXRAead34zswcyFnU4JPUDTQxmk35vq1RRH1KooHOhfMS DQO6TeXSGU1xm8LsFL8RT0k0w53iHtoxlvD9lG6qD8um34ZlfirZFKOxaS5nDNmnyIzbm2yKxRiP iftRR6jBZOH7DQrLjPDGjaitEDMIYr5LTPQo4L9eyl5FCGLUkhuBxlIk7hSPYFNFxFOM5hQDfRTF OJqD7ydyFEo3CdoGrWnady7Y7cM2pXSTnYp7WG6t8n4KDdIE2gcPaWdBJCHRDPCLq41heWNoojeJ 0QzXYWc2FfhEqxjSYDQN2REMzSvt+7ooyKZEjgJZDvZ9E9oxhO/HYirO3G8xR0gDiZrvpLDsfHwX nBtHWH4F0CKemhRr9t1SBWJqyBcPMaTBaGyycqGY4JhgEjw7MdGmMEg8T3Eo8hfh+yndQIpk9+z3 oBuRo1C6mb7Bs4a+9CnyfgoNLuSoZdM2gRj5Tik0GDCfp7hHhnLxTik0BZKZtcTkwk51RJtSaAp0 vNS254NRzBD1KUbT3SxrLZGcRfp+SkxbcG1VzAo9TZNsisKyiWvT7IOPN+pTU8SayH1o/cXxLhZ5 P0ZzuM09Jia4AmIhh0BzuG2f1jQdwzLRm8RoBi5GvIzBx5pieYDWzXL3zfRtg9L3U2gGjFKbMfhs 0qZDIZsSaDqGHnrWg2xKhPMTUvK1YkvtZVOi34/RdFcPNzGx6sGERxoNGoNlPkJjsKhPKTEV/eL6 tXx5tHX1TonoDhmuSou9kEP5fpNizY70ybtpOsThVeT9GE3GRWVbTHinVC6d0Ry4FtZOcQsbLZfI pSvdzOl+1BFYVYqIp6RukOXgVHEg5qvKptSXgsRLNXqCEEAL34/ROFqD7fuFHhNBzCfQdNeKW12S 4PnAkE0J3SDTtLIp4fsxmrkdoaeYU+OBnEX1JrGY8TX8Gx45XpLI+60Yllk9FFNkRgLvvpS5cGRT i2JNY1UpKCaF4kkV8RSh2YXsDycm+MUqnmI0Gfmy7RSHJX5qeYDUzez+R/nc1mwily51k4KY0JfO Cw4lGnSv7RINi3gVOQujsfQhiOm4J/N6YHghh/hSy1F+1I5TWc/jF21K6QYTvXVQBXry4iiBZiKf pFk4eAKXTYkcBYvpuMTNflSK24WF77dE5At9grsxODLqiXdqUaxprHFuECFY+JjKpkSOAstaJua4 bYDITky0KdikcdrUjKUckaNQusHbb9834UeJd4rRzF1/RzGBV2AKEjH5pcAvtg8eLgogyE9OTECD tBbnKc5izJxsSuQosP3LTDN+KZGjUGgSJl46trg9vXSyKYGmQ27LLDyw4oqloVLFGTMm4/S2QujB vl8mfr/TGDpeonan+rrmB79TmUgL9wzsQDFhBF/1+wk0ad/9IKbEUWruSxdoks9C9lhY2roJNvWW bnzLwR4mDDYlddNxzNx6r8NCDrYpgea0KexNGqeFe79Y9FFoNJDorZMWRw1+pyQaYH/aD0wKKuZ4 SqCx//xAMTWsk15sUwLNcAT5p5hQZVWLo6SY6m2q+5S8yvtlJnQcyHtsHzzE4dhUdDgx4UuhR1EG rZWpTHYp0ISpHEvYcuKFbIrQpD30+hRzXlvRv1E2pXIU2RtDaLavvDzgRjfuR7VABiVIxG7QwLmZ sQS4PzjZlEAzQDd2F4dFLpP7KPS5QTfJUl0fTsxg30/rpjpjCAuA9iYNsilCs3BZhYkZIWEH/cXt JzE4k1hp1/EuZJNNxbDMGkOxIjQpZkhc881EWmiDduhtWWXHH7/Gvh+jie3t1l8eEr08Oy/QZFTG tvDXb9q6+eDeJKkbvF+K85ou3XA8JdAst+bBxHg0u3RMNkVoDjdBUGmRy14ARDYlvtTEXoG5aQ1Q xYv7/cSXWl8Fa76Tx8w5l67PDTaHuLmEpydKNiVyFGu5x7cHC1/KppSY7H5Uj2useBlbZprA6Wc9 ZuxaHY1nEjORFhopL+b95hfkFp41mGhTil4SOqxMTAk9JoPjKUZjz111j+8KPCaL+yi0bor7UTMQ yBr/TbQppZvqf1RAs0epo00xmtM0vdMWt1IvjqckGniYPtuBPY2XKyDeKaWbAboxNGF8T/Sliy+1 3HKkurBYf6HhvJ9Gg22DRgYW0HBfulQxnptmgwhh1kP4fsTvZ2N/OOuxaDmS4KPITFq4fC594VzC dfyYj4LRmE1Vd6WvyODJROcCjbGquFMcJmt3uYJsSugmYWZ/xfZ2O+JsU0I3dTrdjJhL534/jQad tvNL+aTUPn5kUwINdsm3I07Wqryf+FLWsw8PzIpLitvg3iSNBhZ/V9dDfZdLl2igNcp+VPVX+m5i JJsiMcstmzXdhHGaKd4pJi20iRU/MuJnPfZdHG2KSQsX8ruZmO53nmzOhWhTjKacV7qbIChxsJuX hgo02eW2DE3I33Tuo5C6adUZQ49LirmPQusGEi/1INY4wUUm0XTo9zsv0eTL6rtzIdrUb2jaEVvj dpU12pTUDXR1nGhq5PfjvnRGsye5X+emmYPBphltitAYzzrcfs26OtgYok0pMTjAcuoGVPMsc5FN xbDM+kvxojhwN9sVMzAXWSbSQgvLoK5ZDyK77FzzZTRmU+jf5F3VR900kaNgCsWyV9E9f+NCXolb 30/pxvUKOPLBp27IppRujiAm8F5zb5JEA0mJbQw+DbSbGMmm5JeCKz3tOU8UczCBrECTXF96M+bX kAYS8ZTWDZjmRbKAaERfukBzOP7iZh12/tx0EU8pMUBNZGhi0U30JmWiCbTlOOjQXlybIEbGU8R9 aB8cxZgn6q/0qWxKcS5UOH75a4ZYs4ocBTMxFswzG5oRdgHKd0roZhb3wPTAUG6JF7IpoRv0KGpC MvcrJS/iKYVmdfdOBZpAxZt0g+YVhze6tnaxlmxKoKmgm0b8fk0stxZorHgCP8rABcIj7k2SaDqk yFqProBlvtimRFJqwm6ulmmvh1gclYkmcN9+3tuKxVomZc7EfWhjfzgHk86Hwh8/MTvPaPagpWv/ OnzzaxOcmYxmi4FTnJHO+PrgvORG6gYt2kbUwgBLEzkKpRuMLWumXceN+ygkGqRuaCVeW5sKL9qU /lITxYSFYzuCiTbFaA638am1eKWb10w2pdB09LZOrymOjIi8n0KDY+atY0nmQsM1XyHG3VPbhQx9 6Uu8U0QTuNeKuEt0BadN5SiI+7B4Bk+bdCvBprgvndHYOA1QmplNBS+9iRwFMzGWzcYBP2qGNFDn Pgqtm+51EwKhxjOJUjewr14MzNnOG7YpgQb6L7Yx+DLXzrSRTRGahD1NJiZl9m/IphQaSLycp3j5 ALo1kaOQugHC6mYbEULpmHuTBBqbyHU2FUkLVTzFYqpj8NwObehpYx7aTDSBW4zvdg5kCV3kKIj7 0EaUsASYY1kdd+Xco7EJguxsKja/dl4ewGiMQBYbPCsy/8bnrjsx4UvBwvBtDIFAVizkkLoB+p19 3/imaTU7L9HU4dyk4ecZdsNVtCmFBvhr7dwEZvtdWIo2xWiyaw45T3ELzGhD5NIVGqwknmgix4uK pxjNeVFMh2b6bFITHC/yRw187kosEOw6A9mUiHyP5c5NoHtTc76ZuA9tnAJmPcxNCsvYlsj7Ke5D V9dsp+/nv5TooWU026Zef80sPFyiXdmU0A3WfC26811kNqHKNiV0g+wYppuwPGApm1JoununokO7 RM1XogHdWCDku8j2LCvZlMqYYHQ3Y09ba6KPgtGcTwEm7Cr6/s/ojmxKoKnAf3OiGaFxpimbIjGe idF0E+buDuZNykQT6Iflr5ghPDA8P5WJ+7B4zkweUTM2LrYpRQjgbSqo2KI0timRo3Ctcad/45vt ZTyldNP9RVFDrDlEH4XSzUAxFferftz1UUg0MIZ1fvAS201Fv59C09A0O7o7t7l0RmOUZvDALBwX vyIY5vfTuoFw/vxRxHIg+v0UGldYWrE1rlXh+ykVj+V0U2MPrbApogm0L+XHsFIgSe28MD4T96G5 kMUZwwrHT3CRMRpbUoulnE5jn1nUp5iJ0YYQwaaMp8+LqTzrcaMbZ1PhZdgXRbQppZsD00A1NjHu OkO0KYVmYH2qxy0jO7kQbUp+KbhvLEUW9yQK30+hmUAk0Q/cQfEMWaNNSTSHuyhWZk802hSjOR0a aH49bYpG8BfblBQD9Etm4T65sEdGyKZEWLawsNQ2fTKIwQfmcGKCbnB8z6a5QopsiH4/RVpYkeGq 47j4vU0JzgUkALBT7DNtFvqxTZFumuewq7EgaeEN2xTppmEAZT8qlo7VO6XQFCwsdewTvj64iKck GhhCbSNmIa2wzDYl0CBLpdlUoLNVvUkKTYKhsCZWGQjfT53i8gouDQ1EZc9eAbIp9cF9Sn5ECxfv FNEEBvfaIpj4Tom8H3Ef2goEZOFumMze5dEP0e/HpIUV91bt1v8wB5NE3k8xMXacZT1V1dkxiTal dIMM5dbCHRJ2Wcx6KN0MJPM+T7F32jbterQp+aVAjB2/sLFb9SbJL4URzIxF/s21Gm1K6gYYIM5T vAJDeRe+H6Npm3j0icaNDD0vimhT+ku9XoaeIvvXLkhGm2Ixbkfy1k1QsVjEm4km0EwTu4EaMlVd NiXiKeI+NN3A7WcjaiOcG/FOMWnheW7gYrAJgpAvPsQ7pXghsZRznuIjB9PkhfFaN1jzdRt49o8S O920buBL2Y9KwS8Wvp9EgxHMRD6S/cE/RG+SQgPzejsQ8l0dsoeW0VQ3MnKe4sjx0kUuXaLBrMDk aXXh+2k0L910LnM1EU8pFQfdlMDgeYhcOtEElu7XPPTI4oQN5YcTE26/7Ceya5idV33pivvQEQ/b 4qjg+4mZRMULiSMj1uDp7+Iq+NKlbvDLWJtySC4kkUtXuml+SOOInFIi76fQZOCwsw8eEnaJZ+cl mnK4cP4IL0NijheBpu02xe9/7RkXsly5dJ7zlWjCRRGcNnOT2aYIzXANniea5KdH8b5p92L610IV z0g+t/m2ok0RTeAe7HXO/hghZhC9ScR9aD8KXcgZu8hkH4ViYqw4d7dO3dw+MNmJiUxFfpS6h0qi ylEo3eB2YdNN6E1a4p1SuinVvVOBUW+HrNGmGE1Hunb74K9C8vXBYXdFcmLil0rONCOFosqlKzRr BpviloNoUwpNqg5NDnzpWdiUQtOgWtbL6WAECxd96fKDV5fqmNETZc7MTDSBxeUL9+SJLx3j0tDD iXG6mZ7hasXZMhsmZptSOQr4UaeYwMRYl8ilKyZGZEazUxx6aLPIpWvduAcmOPs7YUc2JXQzpi/W Ri4yMTuv0OCQxhnBpLDT7RB9FPJLQWdmt3Wb4S5WNqV0Awm7XpBV5zrFot+P0Yy95AJ+VMnBwkWO QqHBDG231KpT8V6oSjZFYobjdj51E3tMspjzJZrAjca14h6e7k1xkWXiPrRlXL4CXULLQRK9SUxa WHGYzNAUX0msU9gUMzGaTl0lMRACVPVOSd1AsbZZJdm710P0+7FubD7cVT3CqFHvIkeh0BSozltW IDJACJtSaAZcW+e5oflw0Zsk0aDvV3eoi2hUPCXRZGfhgalI+n4SDcQMJ5rhmV9ljoLFDMe5cKJp 3jS3bsimKCwbvsxleT/viUJO9HBigk0hm7K9DOG5m8L3Y9JCc2hff80GWELCrgjfj5kYzTTBTWqx BlPF7lGpmwWFJcsX+wVA270mmxK6cZn9hZtULt2Ifj+JBrPXORIP73CebEqhwYRdQj6S511MNqXO DYSsvcXB7gbNaMWJiecGkuDjoEm3yns9BBpzr9w71cKGuUPUp6SYaFNexUXk0okm0LZoYTOazUC7 HzUPZVMUazpH2Pyb7O+b0USOQjExLuxpsxEl76Wr3iTFxLiQBlm0qohZD6WbhH1bC8d+r3hKzHoo 3aBKzffzX2qPNpJNEZqJHZ37gQmFpaJsSqBB9/o8xTmU1buYn1K6yeAK9IZE99cpFr6fRAP+zSlm Rd4k4fsp3QygCTQxPpmJ/cXtXsxyTNPdmkNCSl7UfJmJce5Ez/e/WkulT7xYIEc2RdyH9XAkYv1q tkYVC750RmMkqTCR3TLWta94StSnFBNjAoYr8/08pZltiSabkrqBc3I6baCa6w0XNqV0g9mkfjF/ Ot0Im1JosKO3W4uT/+Bqfkqhwe003XIN/kcdojdJoan4wTu2Yl+nWNgUodmb6YYT8/pNT9OMNiV1 g3m/joNv16spbIrFuPH0z24OhhczRTxFNIFm4dn5NytMjxbRR0Hch7b6FCOYiZHIdfzEO8Wkhc2T JZSv5dtNbRsa25TIUWAg1I/YjlGzyKUr3XRIO3daVrJLOWRTEc0elgcVpxONV3ETvp9Cs6BRrw9M Zj+9LbIpgSZBonckrKVcd7Hgo9BoXn+tW4o00KEwt/ONbpwxHGExpqmYbEqgwdUpJ5oeM/uiPsVi 1t49+BRzPndxNRzn/QrRBBqpy3Ihaxgm7I3fqULch6YbHKexRbxhtJF7aBnNjqfggbFOcB9PJd6R zWjMNOGc2EXhw7KauC9d6qYf7mUYsSDJ8ZTUTcbmV1Ox79uazPHCaMwYYNCyT9x3eF2i3Ech0SDJ xvmjengZMr9TEg2+kieakOpok3MUGg20HIzz8X2BueIp7qEVaJJrDO4Dh9efRbdgU1IMThDsV5O7 OsimYlhmi1jhv95STGbOg/N+hbgPTQxOHfe4Mnm38ZBNUY7CGIMBTYkxg9Xg2KYoR9HdViOL7kL7 V+LeJKGbww8iZOKUGsyZKXWTYJjwvLYCSWoX9SmJBtu9RsZdSVeQqGxKoDkgLBunm+yHe3bISjYl 0MCWUDvFYdfx3mhJNkVoTjFwUYxC0V3jOV+JBje9d8fg+qyWkU0JY8Ae2tGRM/XSjbKpGJYZGt9S GRa59MV96YW4D23QDiz6vP1SDueGuZ0ZzV6O5AbmwiIX83bYpmSOwtXumu9NqmLWQ+omH66uOYPv J/Z6SN3gXXzefj3MMxSenZdoMLE75v4VIKYlnp+SaDDuHjbp5s+N2D8l0XSYyD7D+RKnjrnfT6Cx zbtgU7Zs1icXhnqnBBpcVtKdg3GXoxBibJLbvZrhDVe7RwvRBNYL9hPNiPQEu6sj2hRxHxoadEws gvFxuJhJZDSb99olF0KHXTu4N4nR7E1h7hQf/kcVsStH6sadm44T+ZdHId4pqRu80ktknOmCj+IG DaSdW6SzRc6F5MQEmzr8uYk0OiLvJ9Fgvriv2KineJOkbibwCpxi2gzpQ86l61MMGRORzBQ5CiHG 0MA7lSjtLPbOF6IJrJ4qphckyb0+uHiniPvQ3ik0hoVSt5t0MG8So9mc4BCW1a8Zzo3ooWU0p01h BHP+qOor0FYCZpsi3WSkURGR796iRjYldNMP5xdPX67YdQayKfmlILkw8Nm6tymBBhtnZo8tB3Up m1JooFdgmE59qmNxfUqiAR7Sz9likLjRkE0RmuLYTU/TXH4+fJeOyaaUGPDSDU2gphJcZIVoAm14 Fbyt078J8wy2mZRsirgPTzFoU91OY3inuC+d0dg7hdnrhv3l14/i+hSjCWserHPBJ3qr2EGgdYPR Xdt1LRCzkwvRppRucFuEtcaFpqLFvUkCTd4Mft//Oltk4bZJV7IphQaHl6f13vsrXfRRSN0gh91I cktstCl5biC5MOsugDs0wqaUbnDU6ETTgxixe1R/cPhRM8fm193CTTZFYVn2dYYcJ0/64H6/QtyH xg0zXE60+/Ko5d3YpkSO4kCGq45roS9j4N4kRmNLJ6Bn335UuP3EjmypG8wP97YbtfBHNWVTpJt2 /grnXke/uAvfj9EUF0Cv07/xd3Ed3Jskv9SCiaV5mlhwkwrz+0nddGjHGI7o/pkVIJsSaDBknRNX vD0riWRT6kuBYzIyETqK/VNCTHXkLNOoV/07JeZ8C9EE2lw56MIsPPQmJe6jKMR9aLrBJkYbGfJ+ saj5MpqwxM8GEfzjWwUXGaOxfXcwP3VaePU50Sr2+QrdZJdLP3UTNrA0wZukdYMB9IieqC1xZJsi NOUrw0jsOr0mH93Vrt4pgaZC5DtLFLNzW2RTQjdIaTYKXj9X6KFsSqDBzoVJe4SaqE9J3RzoiZZN rurQMA+tNobu7pvAptwy9yYVogk0kgXslOq0KazzrEch7kPTDYYeK9J2dbHTjdFkt9XGspA5NEBM 3uvBaCwljwm7FjP7Mp5i3ZzXFgQ+dt+E/pvEPbRaN0AI0Mm/6WJPokYDRf5pu5JcWGYMrmRTCk0G 7sO5Yji/W1WiTSk0sG7PUh2xh1bFUwoNtrfPSaONoo9CoGl4a+5kZuiFzMybJMUA9eJ+NYdHk7iP ohBNoM2Vgydqeb9Q5O/C9yPuQ0OD/cUrLg3tYp8vozGbwprv2OEciKlTxFPMmTn2xAL8qOXf8Hrw nO+NbsC/IeKafW7IpoRuGqaBOq5r+PjuMSGbIjRG+fH6UqvFlkqjXmWb+gXNol05Tcz5St3U7N+p ML6XlE0JNBX84mmbDYJNCd9P6QbrCsNKOaGHlndkyx9VsrtvaMxcvFNEE2iBEBayWzx+bfLsfCHu w3p6WxBrmkMbujqqyKUzZ+Zw+RtjjQuXqODMZDRmmsvl0qt3TCwtQzaldIOzrKN/JbHEL9qU0g02 WJ3PXQ2TbiqXrtAgO8Yyg/cXRed+P/2lIO9nNhXGzEVfuj430DZoDRDB2f8QuXSFBndXnGiiilWO QqGBNdS7QBBIUhf3pQsxDTtlzKZKzJiIvB/RBO7kwutLzRyrrE3sHi3EfWi6Ad/P0kChh7aK3iTm zOw+K2DU4t5pKyJHwZyZA/fIXEkpd24sLmGbIt1YvxdcogUTb1eRn3mThG7GF6Y2LCwLKbIu3in1 pXAX4Bo4wHTZVBY2JTIm0LO9bSoEiYKLTKKZh7uLa+BNWqKPQp4b0MV5ioNjYnTGbFMKDXqi1FSk uMiEmO4WAK2DxrCSqE8RTaCtLwdnfwzcFHfpRuTSifvQCCiAXPf8USXM3R2iN4k5M6cj5tuj1D5f PESOgjkzu8tt2Sl+Sdk2NUQuXekG17taajXcN43nfKVuOog5VRyW+O3OTLIpgaZAbmudHy4Hv1j0 Jik0BZz9lWhAV/l+jKa5NNDo0TT7Ifr9FBp8s89TDNXRW9+P0ZwhC9Q1TwtvIUOblU0JMQlTq4l6 TCxhF22KaALtEgXfbzqK8KusLvJ+xH1YrVHPu5CRLEHk/Zgz0/YAu6aiwPpvtw/ZFHNmThx6tg/e fadU6SKeUroZzaXIIjPaELl0pRsc7jltKo4aJeZNkmiA+dNsang0VewgkGigOrvTh6GsLjheJJoK 0Z29DOFHZWFTCk2ZDk0OIWtiLjKtGwjnrYkxEJ0nEU8pMQ12LK2ylw4gmkPk0okm0Fh8DmdTcW2e 2EFQiPvQZhlrODdhQpJ5aBmN+X7AtdrdQpZYWMpOTLQpcPZnwht+25Tg95O6SdCbNJnloIl+P9aN kXNAWDZj7/XmXCCbEmgKOm32pIecqPD9FBpcYXqemyKofsmmCE13TNPnB4cx3+udErl0dW5w353Z VGCNyyKekmigoXwMrk+Jd0qpGDd2G5rwwGSR9yOawE0G5MpcOYSssOTmcGLCfYOcC2ZTIZ7KIpfO nJknGmzhPr6m75SqYv8UozHTxG7nsesTIEbaFOtmIIGotRwcgRdS7MoRupl4h5tNHaG/WL1TCk16 OcLbpvwEgV3wZFMKDVbLVqZV24KHVp4boN22H5XjKkqR95O66e4UE/kc8/tJNFgRGu7eeFYSo02x mOldATOGoBve61GIJnD/KNdwFTgXmuB2LsR9aORjQAI/Fi5keT6+ZFOij6L7aa5An21VCLYpkaPA zoUxI62Ftimpm9dfO3WTw/a9LnLpSjcNQw9bte7zfknkKBQa5KE9bQoO8WVTouYrvxRUhFaNE9k7 DiebIjQDh1dNxTNu7GZuZ4mmoE0VHIl+eqJkU4TmNKLDffAW2niymJ9SYpAbaFVy9gUXWSGaQBMD Du15bqqfZ2hir0ch7sO6XJ1hmCvo53yz6KFlzszh+rbMpryzb1QKbFOUo3Dd9XaKm+8GKlXEU1o3 8IZ3JGa8jaekblDFx/lOhXhK+H6MZrrH97QpiOZva74KzcBcuisQPb0tsimlG2g5MJuKVHhi1kOh wd4As/AV3inh+0ndgDGcKg51BsXxon8U6GJV6urIIpdONIF2iYKY06aWv/1kPEXch7bcuLrHNyyq 60XYFHNmdhz7s1x6C1xkguOF0eyaL2RMFvam3dqU0g3kxLZNhfE99U5p3YArcGCK9NKNeKcUGtyk kY7DVRYfjcHRpiQaXzoOqwzkTKJCU3C6Yu0vjD9KvVOEpi4c0Nw2FTzRLHqT5JfCU3zEtkHkkm/3 YmzoHXIULaY6NhqyKQrLTldgwAd3+bsrZhDvFHEfbl5ACD0OXJ1zXVui5sucmb482ktkValirwej 2fUph6b57XulKJsSusGBuWkZM4dG5igIjX2p6dHM4JgomxJosDE4HcnVx29yFBoN+H4tTh3vu5hs SqGBB8V+VLhEDxFPqXMD95ShCTWYJjgzBZrlqBtmPn3/kKNgHloWY6cYAqHVcLbwQiPmfIkmsHpy lmn9EMH3E/NTxH24dQM/6rwoAsGayqUzZ+bEkGVPc80QT4l3ijkzu59nOCIdihUvyKYIjf0oFDO/ amAb7KKPQukGLXrmmAayJZ5kUwpNAd2YTWEG5dHCHW1KocFGvdWJ8kP1USg0CZtfbQ90YBsUeT+F pkKH3TKqGG8MSczOMxrjzQEVWwnY16cO0UOrxOBo41qRM7MlkUsnmkBD49OHKVxb6p0i7kMTA+1f u8zl0OxzQzZFOYrptxpZE6vPF0ubohzFRDpT++DVfymZo1C6wY0I0zG4XtV5ZVNCNwPbMXKMYGQu XaFBXgGzqQad4ccep2KbEmhgg6qFZSkMaWQx66HQdMhR2MsQHRPmTZJoWnM2NUMFWvClCzQHbmze 3UChTTmJeEp+cIhg1oxUeNL3I5pA+1KY25o7641ihqj5EvehMUdk96NqiMOriKeYM3M4Y+g1kmwg 4VF2YoJNYdPiiSb5HpOi5qdYN57HZC7qIhN86VI3sM/V0CyPZtNakE2JL5UzvlPNNWDd1HwVGmQ3 Pe/iw/vFm+qXbEropmM9PMfqvJxJZDTn6QdmtDWRreBCI3Lp8hTj8StneOXfqSTmp1iMdeY5m1ph 1baa9SCaQGMNwzh8fQHhzGVTot+PuA8NDSTszKZqyFEwtzOjsSENKGTbGFYcehc1X8mZORyaGXy/ LHpolW5KdbrpIYAeoj6ldIPje3sqJ9TDmd9PoDmQ7PC0qfoVeiFVLl2hwQztWnsLOv6oLHqTlG7q co7J8vdNT6KPQqHBevh5iqvnhdwZk2hT8hSje11j0/RmcYo2xWIybooyNMVXEpvYlVOIJvBEg52Z Nk4jWOPIpijWzK6sPgvNJGYx68Gcmba1D+KpHsvqVeyfYjRmmv7aav72szeVbYp0k3EfyG6pDCky NTuvdIO5LfHBs5ifUmjKwHeqYqrt8zFqRDYl0NSGYg5XMHjUYMimBBpH3VB3Cy/+qCTyfgoNVjkM TXXJTJlLZzRl914CmjAy0ouyKSEmwe133jczXKLCpirRBJqY5s5N2AfTxA6CStyHreBB2TYVOOwK 2xSjycO1OHXX73nZFMdTjCZbJRG8rR67Vktm3iSpm4qDCDXuOla5dKkbaDc0NDX2mHDeT6JBSrOU Duc22TvF9SmJBhZO7bAMbtGbXLrWDRSyrVfAN5SreEqiwRjBbGpCk9HD2wo2JdBkdGh2lTUs1RLx lFYxdGYaGmDX/Twkv18lmkAjggQWbmv9j8xonKOoxH3Y/Hy4XVshZBV75xnNaVMFGWdG7HaugjeJ 0dj8lH8Zsk8DaZtSuoE6w0p7FxzqZnAuXeqm+xanFnqTRDwl0JxhWcUHZrgFq4/lj2RTAg1MHlyp DnD+j72ml21K6GbigG7bCxnwR4mZRIGmuNLxLroNb+EcT0k0mGmbND2q4imp4ubKFYfbxHz3Tomw rAJfujXbh/Th4N6kStyHhgaqrLvd1BfdRDzFaLJxNbxU3CdOAlw2xXzpjMZqvph4qXGdtPL9tG6w BJixBnfphuentG6Gs/A4O1+Y2/nmS2E8dTrGvhdycd5PoollLh+W6XdKoOnBFYhsyjyTeHNuQiG7 +5eB+f0kmoy8Aj3236g5XyGmuDWd+77JWK5Qeb9KNIEmBhr1zru4BpbKyX0UlbgPz9vvwDJXi/mb HYdHm2LOTNsuC30UM0YwNQubYs7MsUNkQNNCH4XYk6h1g91AtCV280JGm1K6Sdj6T0sn9lhEtCmF pjvHpONSt5t4Sn8pSIKn43T+DycmM8eL1g0c/mkOhv9Roj4l0JgYtKnz3qre9+NZD4Gm+qF3q/kH FXM8JcS0rzTRpoojTzi2/bNNUVhWMXl+NQbzhCTZFMWazY/v2aClv7YKzyQymjyRBNxoLQJXBw69 ZyfG2ZTxn7hLtHtiPmtGZZsSugFyjj0WERo8jXGGbEroJi13/Eg3yqYEmgPjqWPispxPze+n0UDn gp0b3Iz6eBnIpgSaiSXAwWuBud9Poyno0BY37KPzfhJNgS81J6rqmTEhm1LGkNDC+07tAhoxO1+J JtC+FPTfrBJpu5rg96vEfWg2hXH4+lrFnWK8tu7R7OQCNL+muF24LGFTzJm5HM++NVyV0Ech3iml m4z18PN7BzdpcM1X6gaXTpxoVsiJily6RgP/9XQsl0HRPbQSTRoYwVS6i7mPQp8bLJ7MPTuNP0q9 U4wm/qjiNjHfvFOMJvvGmfP7+6bptoTvp35UP/DaMlZmn4UU7xTRBFocDq+k3cWhbVDM+VbiPrQr HfN+ffMRoIoLc2YymmzE+jAycmC19IqneHae0VjNd3ib8oMIReyfEropuLfK8n7Tn5u9s5ZsinTT vjKkVqcNIYe8H89PSTQl4wPjFojf1Hzll5rT2xTOfjzODdmUOje+rhnnwwVn5g0af4pndS+D6PfT aDxVTI/L2ITvx2Ise4khq72iTozo96tEE7jXpkEuveChft7FZFOqVwA80TmQ2/tZdCObEnwUC2eg j6/sqx7mA7NNiT4KjFi2K/CBYgqEZd2JiXcxlgArLtS9bErk/ZRuGmYhJ5VHD5GjkGgqOibLUVXZ O8U9tBINjO5fYdmgtkGyKXFuJrbiHkQiJmYSNZqEFt42AQqIOdQ7pU6xJ2cBn+2JhmxKqNiVK07d HC61uif5o00RTaChAeqGZeukwzyDeKeI+9Cvdrdzk2PIyr1JjMacNugTPW0qtPHUg3uTGI2JAYue NIQqc+lSN9huWvFqvnQjfD+lmwL5YbvSQ1/6Id4pRpP9lZ4OtwrXuDpEPMVoiltwaKe4O5va7F/R ppRuMLc116YXRDFAkF+cmIjGVaC7u8aOi1Ev2pRE01ymbYRp9cmzHkLMeW3BcTPdjOxeTRVPEU2g vZrL3cXwvlznhmfnK3Ef7j4K516nSAIvar7MmTld16otxvTHT+bSmTPTj+/tlyHUfIXvx7rxPPs2 vhfqDJ135Qjd+NLxPn4+LFvKpgQazEmklF2OVPOlyy81i0/JB+7DJXw/hSZjo17C7OHT2yKbUn0U Fd+pjs1J348v2ZQY0sAlE8taTsJqON7pJo2hF2/hJbgCIp4imkBDgzXf8y4OI/hin28l7sONxrU4 jTBmPsU7xZyZc0+Pff/rpt70xrCY34/RmE2BRe8mxmBTIkfBuknu2lp986w73YhcutINVAS2bsLI yOS+dIkmFXyn8u6ceImpTeQoGM3ppUMbj5WOfdVjl7miTSk0OK9ptBahUa9xb5LUjX81+y6IIhru S5enePpKYqQ0qyLvx2LOL5W8btrhbYo5XirRBFq/X3N3cQqNwVXZFMWaCVeDmUNbA53tEH0UhKbY AufXXxuZe2iVTYkcxfCF7BzqU4KHVujGjRlvlspQZ6jKpkg3tkUNXIF0eqLeNIfoTVJo4O9tmwo9 Jl3UfNWXwqqqpeSnT3UM8U6pczOzy4kmX65oTeTSJRqXaTvddD+IMJRNCTTNo2lhgqCJvJ9ScS0e DRCZfD7av8imRJe8G2DpuFD3/p2iWDNtwtrvv2b+TWg3HTw/xWjyQh6Lvd7Vj4zIeIo5M40X0IWs xaeBCozgdycmzgjBhNIaOBbzLOWQTYl5hgOaX42JMWzfGyJHwWgOJLzZNgWrCT+v5lO2KfGl8Eds m2ouRzFEzVfppiT3Ts2QaWsi7yd1U/FlWF/Z+37SpgSaAxbGL5eyuG4/kfdTYnBr2kbTfcgqbIpo Am0qBxIvNhQW6d64L70S96HZFIYeNj/nz00XNsWcmZbLglx6pZrvwbMejMaeO3Ta6GWQNqV0gxGM DSLEsQhhU0o3A0NWCyH8B++iPqXQJEyCp+o4pmxek/koNBrssEsXOweI6cxFptHg41txLOY6xcKm 5LlxJBsL+zH2KRbxFJNdLrfEz/YzRCIJ8U5JY2geTXdjnzbnzTYVwzKj0YGXwUZGgu93iHeKuA8N DURz1hoXnrsm4ilCY8YAd6+xcIdlbB/MQ8toTIx3r1PY5yvmp7RuoONlTbpvDlGfUrpJOB+ed4bO 6aYKmxJosHSTUjuvePfBi/D9GM3hnH2zqVzdXdxFH4VC0/DcNGxkuE6x6PdTusESoKFBduXHKSab Ul8KhzT6eW94TzSJd4rE7OcO/OJkFFfepkQunWgCLbqD9q9lnKleN0nk/Yj7sB14h29XwO8ebaov ndCUw+3XPG0qbDOXNV/mzHQTudumwg4ClfdTulk4MLcwm3jpRsRTSjcT00BWu/1wYirPT0k0wM+/ 3ynYgfH54OiNNqXQlOFdSOz/O3Zuk2xKnhukiO4YlT1Lx9GmFBrXKZVS6Pezx4RsSn4pdEzOdyqO C4v6lBKDKTGzqZ49Gp7zrUQTGNEMJMl9+jdkUxRrHq7KYe9UpLUQPbSEphw46bS55GeIp8T8FKEx Mb6JcZZgU8ybJHSTdl3jKcaYqvyPMpINsikRh8OW0N3iFFzIyhwvEo3P+1kPrbvSi8ilKzTAKfSw KR+WiVkPhSajX9xw3+F1ikXeT6KB+8ZsqrvuQ+voZpsSpxip8MzC4yJe8U4pMRh6GJrqY80m+tKJ JrAdbrjnPDeRb+sQ/X7EfbjDeRckpuAmNTHrQWiKf/qN2T65VIfNZrJNRTSnGEyl7lMcar7KplQc 7tzrhM/m1g3zUQjd2CAC6KZGavFNEU02pTgXFh4/axT2vh9zO2s0Fc9NcV2sN76fOjejuvxNDnN3 WcRT6tyUkHiB4t33KSabEmjqdGiiTSXmTbr54Kjicvp+/p0Svh/RBJorAJ7oHm103c7tEO8UMzEm 3GZ9bUQIaWdhU4TmNAZs1LO1Mv6dKku8U4SmXDOQTzR1GxGKyaIvXemmubRzCt6WfR2yKaUbGO7Y JcDAbqreKYVmHHj8ztDX+35Z9FEoNBnIEuwUh7XATeTSFRpcjrQphj5QTFMziRINOCbbpnzeT9mU PMXYRzGxdPfx3RwSbYrFJEfKvG0qeTQi78c0gcmReW/WuObuYpgtO5yYeN9gCdBYuEOZS/SlE5qS Nl33978aXX/YW6byfoTGTHO6l2H6TqmSRG+S0g1MK+/hnuwHEVSOQummIRtPi6y4Tc35yi+FaefT ppJPkRWR99NoPkDM+amaE1NF3k+iwYUcCzcoX+dGzM4rNMNlTKprML+JpxhNdrSkl0fh29tFb5IS U9wbXt0U8rELRGRTTBNYXPbIzs3wzCFJ5P2Y+9B+lEtmBo6X7d9EmyI0p00BZafZVI+5dOZ4YTSn mI50/e2roS94k0tn3WS3sXuPqFX3hifRm6R0MzGX3vfkAYqpoo9CoSlYHk22T9rnKER9SqFxDBB2 bkI8xVxkEg0+MKdNpdAnquanFBpcK2PJzFCfaqIvXZFdLlesTV9xaaiYnVc/CkkLN5ricqJN5NKZ JjC7OZg9aOlH8IGn7XBi4vTo8zfsUxzfqS760gnNfqcgl+5osG9z6YTGxMDci60U9KYpe2iVbvrC L3XaVBhRUzZFuim+As0BdBO+n/xS2MaTjzDYbT2hbFMKjctRnJ/K96V3kaNQ9JILGTyT1YBTFEM2 JXpMpotgTsfYNwZ3wUeh0GD7l53i4pqKmuCh1R8cH5hTN8m/4dKmVOk4e5sazfs3YnZecmZCAXIZ IYCva6q8H6Gxdwo8T1u58/GBYrRNUY7CIhhAM76gv/O2PqV0M919YzZFzK9kU3K6wrU4HfGdEr6f InREMu+UrTvIPTBZ5P0US+Vq/mXoyb9TYtZD6Wa4FNkRGTyHqE8p3aBXvtG8YVMSDd5+DZe6fXru w3Yvxpw0n1o9MjptMkfBNIGnMUy08OL2+x4XRXS0KeY+rM6iLQ0UuORVzZfQlBqZ7ZNnDlE7shlN Sb6Nx5hDfKojibwf6+Z07huKKeES3f5NtCnWTfF5v3k6X143VfQmqS/leJNy2h03qBsRTymWyuXq U8MVbx8tTtGmFJqEFehjugzK4xRHm1K6wX13hgY7NW/iKfWlihsmHF+hq0O9U+pHrYDmcIwzRiLH NkVh2WkMA+PwissAv7s6yKYo1qyOePi0qRrYBpvoTSI0JXumaUsDhlkPkfcjNKcYrKpaatVPHUvf T+omjMQCn+2+b0QuXemmYjhvQ8i+F1L1UShCR/Cnz/+vSCRRi6j5yi+F/H5mU/4u7sqmBJq10Kb6 V59oU9h/U5wY8kQx0zYcVdWjyko2JdDgarhdOl7OGKaIp+QHx0RvMpoDb+Fc822SJnB6/wZ15XOi hxMT58Mjs70/N51zFIymBFbchOs2r1w65/0YTcmOsHo3Mf7amyR1051N8RAqzyRK3eB/3RjKfUO5 6veTaAYmpU6b6qE+xbMeAs0ZsWCHnb0MjlFvdwMFm5JokLjG0s7ZM3gK30+iQU7wy8K971fIpiQa HPu0sCyHohvPeggx1bmMhmbO4sRwLr1JmsDm7+LhaS1EjqIx92Fzr+RpU5GeoDFvEqOxdwpJmVPc IaltSuQo1nBoYOzusinuTZK6WW47zXkXu9a4HWuSTSndYBuPtX95mxLvlEQzEU0+L9WQo+B+P4Gm 4hzETh8GF7Jzb5JEg+xfVlgqjkhit3CTTSk0wcLn+t2mBJoRGq6Wb34d7PsJMbZSzpcrWvFvOM/5 NqYJrG5zj9nU8nXNxH0UjbkPTzG40XLFJTc7DiebohzFGTNAqGH7GcIi3sW5dEZjOQpfkFw+06b4 KKRuVqCmClM5SdmU0A3+163FKcz5ily6RIPb91K2cT5fWFLvlECDzPY7fRj6b3jWQ6Ax8rmQ6mgY h9fBvp/WDfJRpHVeHL/1Jkk0DVPy9oZ7F7JyjkKKmRiHn7pBhr2bd0rRBLrOzNO/qf6ByZyjaMx9 2DZl4/dfs3fqDd+P0JTsOF6m2cavs/OMphTXCX7lKPASVTvdhG76aeHBpty5UTkKqZvpTPNwFGeP /E20KfWlSsZz092Ujr1TvNNNf6nuz03J3r/h3iR9buBH2KvZfS69CptiNN0vAMopNoeod0pxZi7M QpqYMFvGNV/5o1yRP7mlbp+PvvTHl/o2hvT4T8Ip/oIeov2vcBWf/6d7gOlbTPpBTMeR++JaBQzN WovQZBJTz8AHrnB7ijEJbg2XzJfOYtpXwvYLvyR2ixmMpkoxcDHYmK//UeMQDVdKDH4ZC+Z90W2M RGimEFOx5DfdvngTs7lW4wfvUczApdR2br7S8mL6B4nZsYkTY4uisFo2Y89+FWI2fifG+iaAHSNn XDa80dTCP4r5tpLj5jiv5rGCGFZx5lGjtjeTff/raWLBv0EmRv/AhLu44QBLtl1dXjd8/NJxfj6v mxPOyxE+f2MkINk/atNS9FTKGUTmlY/c/vEf/mf+/Pc//+2vf/7T3/+Pv/w/f/nXr7//69//p4Td /DnOP71X+59ptAP/p/3/nCFV/od0hjJHH/1o6R/O0Gkc6R8+jn8PMPHPf/vb3//0Lx8f//DX//Kn //TT/91v////m/75x//rL3/7b//89799/J//5V/+w8fjNPzjn/75P//Hv6bP/T/yx+c//+Wvaf/z /H//33/613/6838ylX18/nWfzH/6p8df+yc7RPjv//Evf/3Lv/znPz99PX+F80X++N8ffnA1J7dR 6zKGBe3t/krnG/kpNiNxxykWuZi+xfKaYBTrxqG+xR4BLexU/BZbB6Gd8E9Ga+3dw4vtE1MaJtb+ F1Hs4wmgh+AhNsRwplt4yb/FviKg70/2q1i3b9nENkI71g3au0+WFhJnbl0jxffHS7cS7Q9iG9KS 2EngA5YTob3eRX4dX7ot/pMV6GF8KGG+6hzfPsSvYicGuvb4wWv3EAvMSR7t7QGb+y85tO6LXWjr DdofxA6k8D0/2SykhMUn4XIW2GV4iu3YD2piRzwJttHj2yH/Dp1+Fdtw/a8Zbye0Y96g/cEcOoaq hrbFA2Z1NI32J7G4eic7Wq5vsZOvmm8PivyopxKqN16lBO4F/VWsR5sc48i32Du0P5lD87pdnc2B s22/ih1Rt5PFZkJ7uZXsXL7EYixilcYcxdqF/B3W5nfFYlRhYgtdjJY61mh/MAc3R7E/GVtZvUF7 K9ZKSv7RyeKTsZVdvjZ73JfYUndL+lNG8YRe+7+8OQi+I8j6ntiMK+H3v/dJj86sN2hvzWF9ZQzg cnKvxcfLyiTaH8RCZWGHVDnRJxuM9gpAbg+Y8R7gE1lxFOpbbH6FR/1dsb14sWWQ+3G8+jeD+3H9 v5VrV8LLWx3Yy094FVWfmQ0QK127PMO5XfEGWzC9F8QeGu2phBIencn37Rx0Eh53170SDof2xHZE H8wWbH9fjN+6RbGsBEslF68EGC3/Flt4LvMh9k4JE1cBX+5HJo9xvfonwhN5owQ7t7g+I1/bEQPa 9vLBvvN/KFYqwc03miNK5mDkyd9og9h7JXScTN0POhmv2GLzuA3ulZCCs5TIWTIKhpiDR7FSCY72 08yDvJolGv4eYu+V0IpHu4Q5vJwl/+j8oIRj+NihsRJgEPg794pitRKQ9MJ0W+M1vmByIYi9UYI9 4DjdmSvSnX+LBT7c8DrcKWHiktfroqS4bMHOsFBxuFcCcILtf1+VT8KrAhHE3p8Ex0mXDyS0eoid sNLOPzo/mQMyuxpaVgLcCd/JfBQrlDD962AXZaNPBkROQewPSmj+gCkltLeTKvNbrGORM7SZz215 O6nyElu8bmem7EcTs5nwT9TtU+wCIoItln2wxv7tXVLlKTZNbw7QQfUQe5+m4LjsKbYkUIJ9MnTK Hp+sv51UeYldHm2dfBLYbb7LfsxvXToeSjMH9mqARPS3pMpT7NH9uWXXbvsJbyZVnkqoQbe4ZPBb Ce8nVV5ii0fb2L8Vur3LfjzF5qAEr4PrLeNr/FexE0sK9jpQUmXcpik4LnsdsBpe3sqxQ387qfIU i+/3FsvJwHmXAvrBHNqMuuVPdof2B7E9HDBXaXuJfTOp8kKbfChd+dx2zjb/LhZLpjYNQJGOXWnv JlVeBywoYR30OnzwNf6rWFia8MjacTKQU0B32Y8XWpzds7Y4enm3ObyZVJnfujzQT8gFd0R/o53v J1WeFyOM2uz/zKAAat6mgH4QW0MmHzhrn2IZ7V324xJbMzbd7OxHC8Z7jSa+m1SZ32LcUtdi9MP0 OnQ+CXfZj5cSKp6EvNu3ghL6+0mVp9jlii8ZWQS+xU7x8t5kP55i0Vjt3M4RP9mY/e2kyvPcTuxo yo4q4Ym2vJ1UeYg9sJ38umqEazfeTqo8xXYc7toXY9TtgmaW35IqD7HlC7/7qSzkN/8Wm/gk3CVV nmjxvrrSwhTpwF6k35Iqz5OAxnpVoEgJ/4akyuuAuU/W3I328Thg9e2kylPswFmifLj62bcSPt5O qryMd4WXl55Ic4DfTao8zcFtX8vV7fj6eNwJvMrqLqnyusabR9sLKaEw8cZdUuWlhMM/kWmRlXWe TL5LqjyV4Pp8LNEq0sLp7aTKE61rbsrXjFNUQn87qfIKSZYP/A+O0Ht+O6nyNN7lsnY2oEcXY29v J1Vekc7hzSFTuLdgafRvSZWXbtFttkcoRWcJU0C/JVUgJPFoi6ic9reTKoDWR+iLzQHuhN+SKq+Q JORqROCfP95OqryUMIISOt0J4Ij+llR53MMTO9uvi1K0lLBXc5dUeYp1fZFbLGc/BNE9/NMPnH2L DVk77AB4iK0cl90lVS6xFozCHaASrWlP+76bVHmKLUj+mK/u8yAWZuZ/S6q8xDbv2o2UgljbKfFu UuUhtmNb9xabCqN9P6nyROtf3oyco99oRSh9l/14iLUORfxkRvCCUmNG9LekylMJ1Z2E7Lb5PpQg zOEu+/EQm0IonbGj+httuUN7K7adFyE+6G3XSYPYyV1Ad9mPJ9rsClv5K3NaGMYxfkuqPMQOZJLa /u4IxmtWxuf2LvvxRAtsSRdaKr7Yz3k3qfJEuwLa6CylnYp9N6nyRDuS161wP+5duzux3Y8D27nN hLbepYBuzSEhAcQWW8RJYC7QX8SGPULZLVX7RitC6bvsx0Ns3u3OL7HDmceFdkKJ87ekykPsQuK0 LRZIWB5oj8Hda3fZj6duV1CCuBOAHvq3pMpTt45oa8cO1FKy+E64y348Lkz7ZHDASncNMQ+xwBn5 W1LlKdal3IvNGpA5TK7p3GU/XifB6bYIt3kN7k/4RexyraZ23w5+Iuv7nSoPscVV+PdFWeMNNoG+ 6Lekyvcbh4uit9jWyMpWfTup8kBrFSgUW04PMrof21l6M6nyPLc+I1r21H4QW+bbSZXnE+lzjCY2 KuGYnAy8S6o8T0IJrwM2xFxic3s/qfJ8dIbLLJ0no8arxk7yu0mVp26bq/jbuAdZ2VpvJ1WeJwEb DPcNVkkJvbydVHkqIYcnclU6t7O/nVR5KuHAsfzzZIheO8HDdpdUeaF1PUsZN9M80b7fqfJyRJGY Qz/o/4ZOlac5zOpvsO7uxUsJ8+2kylMJR/MnYVR2ltbbSZXnAYu6rSHlfmXK3k2qvJSAw+WmhBbF Wn7k3aTK85MtpDmyT8bGO9/vVHndt8nrtg6+at5PqrwuxuV1m/jcwtLA35IqLyvLXgl1kRL+DZ0q gDaI5VAaaMR+S6q8rKz6azwO1DzEvplUeVjfohq6fyGfHVZvJlWeYt14Z3a7Jp5iBTM//BN1+0Ib UpdJ9Iiyf3uXVLnEno5nbV7sEG/Z+0mVp9juDtiBlM/fYufdQM0PYtv0B2xQuHeIUPou+/EQ25FA 7ZFUoYtxzLeTKi8lLC/WJ5svJ58d0bvsx1OsSwZaKF3ok+W73o9bsR0pFq8nktCm8n6nykNsxq2y l2tHLSXbyt5MqjzENlwEc5dUEVXpu+zHQ6xt/Mar5nwyEwVQ+f3xn0eIff4l19u8kDH0W2zlAOou +/FE65uQz7eNToIVfd5NqjzRLteztJCL8Vvsv6FT5SE2bJ8sFTfCPNHepSluxZ4/GpVQJi6PuwTt /4t3kyoP3c7z0YFze8ZpZVImfzAxyM9iy3nA0HhP9MCc/VQC99XcZT+en6xiOeP8z0yqStsk/btJ lUtsTb57zZo2qK9mDdbtXfbjgfb4OrpHm53Ujfa4SwHdia02nQE3mKE/GO3dQA1nPx5iT3cDyZGq Dd3J5vk3kyoPsfVEC0rYXNjUDyaS2HfZj6eVuc1apTov5+NxwMrbSZWH2OX3b5fllPIQe/ANdpf9 +DaT06vBk2BlOU6qlLeTKg/dmj8LVlYzEmg+0Y63kyqvO8EFUOoG+7ckVZ7XuCvI2gzUQaF0+Xg7 qfJ8IjHlszP5ha/x/HZS5SF24WKvS2yLSsjl/fGf11vm5nmLqJfZ/od3kypPr2a5ZGAXEfrOiL6Z VHkqYThvfLrlAA+xsFr+t6TK8xr3SlhuMd1D7FxvJ1We9+3CWmS5WjKiErjOe5dUeYidvlNlp4kJ bS9vJ1WeT6SLdOyJHCQ2f7ydVHmJRXM4xc7FJ+H9pMpTCf3waGOpyIZD30+qPMU6xmHzciiJfZT+ dlLlpYQWxbIS1ttJlZcSstdtowj9ADrp35IqINb7CQdFkdttfjOp8vQYB3aqGCs8pYVt69e7SZWn lWHn9R4b5qGP+X6nyvNB75gbL5XGf9LO5rybVHnqFo7t5ZhySJLS20mVh87Pi9ENjB+44eOhhH/L +M9LrHsirbkzFg1XE+s54J9+0dZDbOs++9FECog9xrukyoPdrbrhpN3wzbnxf0NS5SV2+ISVT9p9 /Bs7VZ5i3Qbz8+U9wiCYVU5FuHeT/XiI7Zu47iU2I6vrE+3dsNKt2Pq1sMHb8reF0IrA/y778RDb /CYSS11yojXdpSluxXY3SrWTKtyzJMzhLvvxEJuR2vZKqohk4PudKk8l4Jja9iDZeBcHp3fZj4fY gZyRl7+76BpP73eqXGKLuZk+qTLDaJXZHQdQd9mPJ9rh0Pav5aRe9+16O6nyRLvcCPaied5/W1Ll ITYjAfR+LcZBUeR6v1PlIfZ0PzCJba5eSAZeI+TvJlUeYs8IvfonMlVCezuHfit24Yr0qw1i0YMu +hPush+X2DPwrxDofzZblBrNYdT3kyqPhEB1KZ/PfhozU2OJDqu77McDbXKNWntHEk9xHvntpMoD 7XR94p89CRqc3YT8ZlLl+t/0gTuuzyvp/IShxHns6ZJ3kyqP/03qbkXlpr11gvd9y1Z2l/14oM3O WG3JSaeazqbbfDOpcv3vp+2QhCfSNvFyjrGIHtGb7Mfzk1Xs/RhzUw8HtLW+nVR5oG1fGYfs5tzb Ab3Y3Tz/ZlLled9OV0MvlF4zZ6m/nVR5vbzuvi3nASOx5X1OlecTiSmfXYvs9OhM5gK6S6o8xE7n fV8lTk6q5LeTKk/dYmJ1K4Fe3tTf71R56rZN/0Tizp+HElJ+O6nyEGs5RvTBbGKWXLv8PqfK8+X1 4z9zu0ZB7JxvJ1Web9nATmxLsnDdYd0O3t4o4YzDhnt5G3Gvpb0F+t2kyvOJzM5P6OfFQue2M+/w XVLl6SeU5LMf6OU8xJbxdlLl+URi14+l3CslsRMksX9LqjzENj8SaHsjyRs/oGX6t6TKE60brbIt upxtrh9vJ1Wu//2wFBCIHR2Z/7/F5vx2UuUpdqCTPw8xJmxTqe8mVR5iBy7r3fsqS4tvmW0wfTep 8vBqJq72NJt0/5lL7IDy8W9JlacScPDrc5z37ZTm8GZS5SF2nd43frJGHFZpb4O9o56OfsJ1BZ0X 4+GoWsbeQRHEit6PX8Se3nfyYgtPds98g/a2ujf31ONThsUSfCeku0jntjS/9lDaS+zYl3ZAe8y3 dbujOgtBfEG2OTbJj8e5FT7Yz2KtWR6VkFzO8aGEfEdCvu5K84GvZkc+/OjcFbtvxR5+e3kprjb5 EJvG27p9okWifSvQVr4T2vufLPXjEuPqDtWSge/0fvwstrjVpPuAFQ6g5q0SthBZlc4471CTosYa onL6o1hDi5TFpe0KThBb+/u63esqa5hD3+i5QPBv0O0We6IdrkoyRLhn27Zv0NIqzWdVuuEMVM24 DPBbrAhOfxFr+U507bivxqrSd9T/oiq9Hm9ZchH6eRKIlmGJDqufxdqNhWmKer7ENHM6Gi9xeAgk JVz/+2YbyeCT9WvsK6DNfI3/LLZeC0FRCZMYZU0r7+p203uYmIwxry1iZP6E/L5uL7Hm32IndkuU FrZQut2h3UKEbtsenHrp1nLjXCq6G1a6E3teLdjmsBc3UnptdL5vb5VwoS2OL8HQLhpMmKJK8rNY S1g5b9xWtX4EsaOz+3Erdi+xbuPULbwOhrbFA2aEpW+jnY8uoCPjAVt7zDagzfw6PMTSgu2HbpMP /E//tobKqXk1dx1Wd2INrbtqrDObUpfjFq0YVjquOwGd789+/mcYrRgT/llsddsvt26ZRGLUu3N7 CZG6ddzCvbsOgIdY0S38s9gTbcaMqB044sm3zUB6owunLqs53RZAHXjVrCImDa1L+d1E6yXWDhRa 2Syi124MvsEe8Ve9SV3mnZN7yjjjovOYtiBW0O//LLbXTZ/8Qns+QrTkYsCQ3a9KmPYRz3APacZs E+5i4sTjLi18J/Y8UPiFDG3sG//pJFxCpG5duGfLiKe7wj4fXO5atzdie3fFbcvfxqY47Sf8nHKf 2bOj2/o8Hzx8cwG9K9as4Frz2rzYw7Gk3ThLP4vtYRvFSmdcQ8bb2P34TvXEl/c7K5JwjcreEN+i 2E0xpNHeiB1pL3B9oc2CYNm2k76tW7NZWqFruvUsad/sOu/qdovtyy1jMd1OqkWOxo/OQ+zQdYdl zPPIAJOuvQtOrCL3+1nsON0NJO1ZVYxb2r5ivVFrcVx2pYZGxur2Z5rdtVdcus13NZ1bsdVoT+tL 7BlMDNel8R2XabQc6Vxip5tJOdGfbySFe+Ik/CK2TqSKO//d+tFXEGv9txb/r/M5rXnUM349yv/k mrE//vz/9M9e1fVf/8f/h/vfynE+d4/9bz3l1vb+t1T/2P/2v+KP2P/2X/+H2P/28cPmt//6P/zm t/Pfn5vfdBXXJfnsn7aWrOM1ZDTP5Am2fCPQtWd+C3ROSTpoTNlPMISqOCFcvmFyC2SivlRu6uGM cPmGZBPoXeqPb9rO0IiXPyLCqymv7TW7IDC7pPQl0Nzrb4TD/XUXUT0Euk12J+Lpy8kmsEGLq0eI P/kbodtcZggnpXJxN7lHyBz8trIVE+TrjCco8G3wk3//ymmFr8zk6FMQc95/ZdfyZAInefez8ZTS HcJk3IgQOKZrLs0LtAGT2JJwj7BPhzB9HfSVNwt4KJPysbkaGLvfjfKZikjYNxhr6O6vq4OdnUDa 33B9ZeZx5GPzQugo8MteSe4F1sUMjpMEPhG6vcr2kegrNysrhV6G+3NYHFWw7e0tMcIwpWqB6iuX FASKMh0I7E6gPIdoexshpWDtgoxdIfc3tiOV3QKJb3h0bkflY/P9k1011r7yokm+DhsOm/vrfLDP r+xIVY3Q6MP9sa/ceAqZj80TIRqGrUdO9FE61Pw9Qj7YIV789BzhT4SCTfb+HLoYKSVR55/QAOUF 6vvQ/eQr/g4CxcKQO4TDFRiud5lqTX2KaacbhN3Fn1tgJc+hgw7vET7aut3aJPu/I8I2uw+ZOVgM Kz8QjhU8B1ekuBDWO4RMECIQMgmxNcdqhEqHY7gL9nAMJN8IeUzq/hzm6B8OHqTu6UbgG+fwmgsM AmumDql7D7a5wR072LR5bAweOLtDaBcsUoAYQiaXTbzlgI/No3cjfQ23VGeKraQ9vzzY0HBHB/sU uDDjfrpzg0uRhRux+di8EGI+2Ph1qf7W07xBKChv89eRA0KqCSxoAfvt1Qvt0PuR4t6cMm8Eynd5 hFcvDhk/Ap/g2/xwDkc82MSgbO0f0bf54Rzio3L5h7znilvCbzuGIudoV7acGnuwNw1T58OOV/4e H6PlaX3NG4Ri6Pk82FgMt+nkRFFAYoK6779OB7s4YpGLqJ96AY7CfW3353A4hzO56uoDYRU82T+c w+AfclFuFkETfn8OXRHm/hz29xDaOcSu/O0fcivBq0TwREjH5lFITF/uGd19INGDtXHGb4TJ/XVx sG0hInY0D2rrPjbnpUbowttvhDiL9Fk7jVKZf3iHUBxs0yGUBw0h5RzskdCDleorV9ySbB5sp43B FqzpQToW2DwB4JW3iQit3zbmHO4Q7kwSmp6Vwdg/ZMqrO4Tigk280lmQr9z5h8OvMjeEnCKoYhfZ 3bt8flQ3XrBfPfoo45035RJ4hhHJuXPdEW7cC7xDaGPDzoO1+UuU9yz3/Xpsrv/EcqSE5//FOAXG r9xuKZzFm2KGhW8KE14euwYeY71b76u6IvS1IIzDW94Jf4vQGsH88oHGO8DFDOvdu5ya28Szif3p oe+i6HR3H1oYgb2QNuZCoxhdjBXeIhxfNax26VwlThw8/nBjp8DtWngkq982gdKbsjdKwt+uefMr eIH1diuXEFj2VMnzb5fh+kYeOjRnKfjYtwiXn6M935Tj4yMKrEzydIfwRLSwXb2s3WrkBSqir7uB tvPVK3iwe957zKIO77ZvydkdR7rcLQ0eBW4dBv/wdpLvcD/RpiZ5C99oTOZ0h7Cf5w6HP0baiamg Q9HUKVis9n+iTc89n47qqECu+xBq/v0Xgach72L+839rs+0u3/f52Gx509dM11d2xYB9wXIrXOMe ih8uh4zdE3svCQk8uEfpblbA3hAXp2S3Zf7xk3/ouSaB/kK91n1zuo8R3s0H2BZTt3VkEH3yw4M9 3hToGY03RUCK57D1++51ccHOuFWAMku2b/N3HT7flOroh883hUd+D25ruhsvyDbsi+MFtq8jCuzK nbsReB4bdG7sOpspPgFNtNvcjRRkX4PajKAfH0GgNfmxw6kFmg4dj3VxzE7fOnzrK+9Ok2z1E7i+ ShObhbroRL4TaCu2HCmU6uU094kQ3owO5MNxvG4KDW7GX+KhvxFoA+2BPzXT5skhJifuxgWMfQNz DraAgCn37vv6lQ4zFgqN5IEvhyIs5WZEwGanMDtX62YHCT9ZNSXdCLTFPthVav3G5LTXyefwdiwg CDTWDcrBzlvCCRZoNEk4yFLOn0yRlFXxCeHNKIDRPuLSodo2eV7QYROd2jcCt384nUCek2vH3SSE QHiGFe4rZ7GVUfFf3gnclwOew+GaJx86zG8hnI/xtYrOUh0iSzwF5+WdQCN2RO6iOkVJvR1iruim zf/UYRloy0tsF9+pqojwRqDpEANwYwWj2mgXY4u3rf3J7zC0NkZeSlzuJl1YYGQWPwUmcomVDu/a +U2HSGZQpi+WXjoU3Mx3Ak2HSDlpOiwU3god3rXwt+J8GfO5B3cEiYmWO4E2K4iJoD2OxDc234d3 bfuteiLqPvZ4nBe4CX2P9wQaiyI6S2fcMmnjUBNzV3et+jZchFkRY3QhgWrn9p1AI1AYcNu0Qcs0 jv3dSYc37fmt71rEC+H68hX1jTAJ5rwbgXbuRvgok3yb9o4On7wyBYtcfe03LiAUtnwn0Pgd3Vc+ aK79Wn77BsKru/90PbCn28b6uQkq3zFAs8DzQu14fY1rYCjosItxgZuOfouXMRFkQxlsKWJN2Z1A 0yEG4JZzGOQS17uBBtHFb7UA+Mqj+hahjzv/8E5gvXaDvQQmt4HlW4dipuemc98oqabXYVw9dOx2 c0J4I9AYC9Bp74fjZfrW4d0ogA/AtzEeFR+V89/tHIUkxt4B8mtm6RI4rPsfPorNRFCbltF/cURP odkjzdL2gOnzf5t68Dh30V9F9FrgHG7T7R5ays6Yd6FQxHr8ky83/uiYuD4RpkC/tnUoZrtvBE67 7TAxfqqAI6nOccrtlMMxkRbs/L9IgY3BfrLIwd4JnGXPWgBCY/yMCNfdkIdAePoi7ivbyj03X7qp ONg/vBM40/mDsDZqw17OW/rUc6VK4HmrfKYzUFkvW9s6xKHNjTAJ3+ZO4Kw+VWUfyV/Ztwg3HqHD iuPO5zksuzvQ61BmibXAmXa6ERB2tz78cQ7ZltVPPu+tU4cdeZH3Vz5GQJjS3cJDFrjSV/cDiGck VOLElfC+HnjkOVzOlnPwRW51qAXaOexOh0YaHkckdz3la6SVj1xKrbWcF8j8Y8Dojz9//Pnjzx9/ /vjzx58//vzx548/f/z5488ff/7488efP/788eePP3/8+ePPH3/++PPHnz/+/PHnjz9//Pnjzx9/ /mf+/L/2eMueAEgIAA== --000000000000fe52e705ec8d1e3a--