From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-ej1-x635.google.com (mail-ej1-x635.google.com [IPv6:2a00:1450:4864:20::635]) by sourceware.org (Postfix) with ESMTPS id 6ED313857C4E for ; Thu, 3 Nov 2022 08:55:19 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 6ED313857C4E 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-ej1-x635.google.com with SMTP id n12so3324681eja.11 for ; Thu, 03 Nov 2022 01:55:19 -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=1SqHdHEvPwCPvbSm8y50b4rz4YXsloHlLR9DqRWPBOc=; b=JhHPFlSfewEWETguRZmcwLO/3nAg7tl67WmCLoOqth6rWAYSwmu+hAfFB4FCc2zsE+ 2VMN3UsY+Jxl21nlae+PdT2juFWKCqlqazJutdhlLkunAPM4sFi2iq1oXyz9HV/a/syF 6G+f0p8XzCwIWKbEhCM132KgS+4/0zTb8ny4usU05NC9liO4G75i0i8Xe0IYQ/qmH6hz FVAj6kODZa0sXkxQe5Ou02bJnBfPmusmtDEM2nE9ldz6lK4luCBTX8PKeHpOw9ftmEzm lJzx+J1gM3lBaiR6+rx5NmUsmNwz3NC74jUIHcmrQmWDj3ZWjcRUA9ivcA70QaDcnn2T Kt1w== 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=1SqHdHEvPwCPvbSm8y50b4rz4YXsloHlLR9DqRWPBOc=; b=yne0Y4ukaurReFHBizpv2T0XhgaKlz1lv69c5P/Z/se4NZ5s6Hy8JqWjf2jef3HShi PH8mm8kjfMxUziI4RtnntSFm/TlmQm6m8UAyP7MW4DVmNnOG3f6l5B+vu/9RagNY5//h zlcfbdMjiUXfKcbqyn7B16RMhbPsvLNsIkIyGA0lhvXzs6Ae0+GTogHvx7T4z8ezP797 d9qXGPhKWcX6TJ/q5XJOcS3mn3NoF6jlSDnFUj5lFi2hjWzzm4ehQsw0+ZerwuQhgIDs wch4SjoyS66PYpSSrQhJoKqSso17BYh7pO5woza+uMqmrsVpYt5yABkCv8KsGqwHOTxg oWJw== X-Gm-Message-State: ACrzQf1J0DnUmoh5A7CKhmTJNIopCL5T5LIF8nZNmS7JNZ2x88X8+Fih 1rNaHJLISRGlmXsM/x2+QCBte0WO75nKqEDp8pwNFWeKdhE= X-Google-Smtp-Source: AMsMyM7sIgoLuyzojEe/3cgEc8LPgPC5z31U/tRVd4R+ik3A4sSMKJxNEFieD/SsmytDzrqTkiD3qaM3TZytic119Hc= X-Received: by 2002:a17:906:fe45:b0:791:9624:9ea5 with SMTP id wz5-20020a170906fe4500b0079196249ea5mr28619847ejb.282.1667465716164; Thu, 03 Nov 2022 01:55:16 -0700 (PDT) MIME-Version: 1.0 References: <20221103085314.1069528-1-goldstein.w.n@gmail.com> <20221103085314.1069528-3-goldstein.w.n@gmail.com> In-Reply-To: <20221103085314.1069528-3-goldstein.w.n@gmail.com> From: Noah Goldstein Date: Thu, 3 Nov 2022 01:55:02 -0700 Message-ID: Subject: Re: [PATCH v1 3/4] x86: Optimize and shrink st{r|p}{n}{cat|cpy}-avx2 functions To: libc-alpha@sourceware.org Cc: hjl.tools@gmail.com, carlos@systemhalted.org Content-Type: multipart/mixed; boundary="000000000000b0293905ec8d1d24" X-Spam-Status: No, score=-9.7 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: --000000000000b0293905ec8d1d24 Content-Type: text/plain; charset="UTF-8" On Thu, Nov 3, 2022 at 1:54 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. 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. > > strcat-avx2 -> 0.998 > strcpy-avx2 -> 0.937 > stpcpy-avx2 -> 0.971 > > strncpy-avx2 -> 0.793 > stpncpy-avx2 -> 0.775 > > strncat-avx2 -> 0.993 > > Code Size Changes: > function -> Bytes New / Bytes Old -> Ratio > > strcat-avx2 -> 685 / 1639 -> 0.418 > strcpy-avx2 -> 560 / 903 -> 0.620 > stpcpy-avx2 -> 592 / 939 -> 0.630 > > strncpy-avx2 -> 1176 / 2390 -> 0.492 > stpncpy-avx2 -> 1268 / 2438 -> 0.520 > > strncat-avx2 -> 981 / 2563 -> 0.383 > > Notes: > Because of the significant difference between the > implementations they are split into three files. > > strcpy-avx2.S -> strcpy, stpcpy, strcat > strncpy-avx2.S -> strncpy > strncat-avx2.S > strncat > > I couldn't find a way to merge them without making the ifdefs > incredibly difficult to follow. > > Full check passes on x86-64 and build succeeds for all ISA levels w/ > and w/o multiarch. > --- > Results attached. > > sysdeps/x86_64/multiarch/stpcpy-avx2-rtm.S | 6 +- > sysdeps/x86_64/multiarch/stpncpy-avx2-rtm.S | 7 +- > sysdeps/x86_64/multiarch/stpncpy-avx2.S | 5 +- > sysdeps/x86_64/multiarch/strcat-avx2-rtm.S | 13 +- > sysdeps/x86_64/multiarch/strcat-avx2.S | 268 +--- > sysdeps/x86_64/multiarch/strcat-strlen-avx2.S | 76 + > sysdeps/x86_64/multiarch/strcpy-avx2-rtm.S | 13 +- > sysdeps/x86_64/multiarch/strcpy-avx2.S | 1236 +++++------------ > sysdeps/x86_64/multiarch/strncat-avx2-rtm.S | 6 +- > sysdeps/x86_64/multiarch/strncat-avx2.S | 477 ++++++- > sysdeps/x86_64/multiarch/strncpy-avx2-rtm.S | 6 +- > sysdeps/x86_64/multiarch/strncpy-avx2.S | 743 +++++++++- > sysdeps/x86_64/multiarch/x86-avx-vecs.h | 5 +- > sysdeps/x86_64/multiarch/x86-avx2-rtm-vecs.h | 26 + > sysdeps/x86_64/multiarch/x86-avx2-vecs.h | 27 + > 15 files changed, 1680 insertions(+), 1234 deletions(-) > create mode 100644 sysdeps/x86_64/multiarch/strcat-strlen-avx2.S > create mode 100644 sysdeps/x86_64/multiarch/x86-avx2-rtm-vecs.h > create mode 100644 sysdeps/x86_64/multiarch/x86-avx2-vecs.h > > diff --git a/sysdeps/x86_64/multiarch/stpcpy-avx2-rtm.S b/sysdeps/x86_64/multiarch/stpcpy-avx2-rtm.S > index 2b9c07a59f..189a288053 100644 > --- a/sysdeps/x86_64/multiarch/stpcpy-avx2-rtm.S > +++ b/sysdeps/x86_64/multiarch/stpcpy-avx2-rtm.S > @@ -1,3 +1,3 @@ > -#define USE_AS_STPCPY > -#define STRCPY __stpcpy_avx2_rtm > -#include "strcpy-avx2-rtm.S" > +#define STPCPY __stpcpy_avx2_rtm > +#include "x86-avx2-rtm-vecs.h" > +#include "stpcpy-avx2.S" > diff --git a/sysdeps/x86_64/multiarch/stpncpy-avx2-rtm.S b/sysdeps/x86_64/multiarch/stpncpy-avx2-rtm.S > index 60a2ccfe53..1b252985e7 100644 > --- a/sysdeps/x86_64/multiarch/stpncpy-avx2-rtm.S > +++ b/sysdeps/x86_64/multiarch/stpncpy-avx2-rtm.S > @@ -1,4 +1,3 @@ > -#define USE_AS_STPCPY > -#define USE_AS_STRNCPY > -#define STRCPY __stpncpy_avx2_rtm > -#include "strcpy-avx2-rtm.S" > +#define STPNCPY __stpncpy_avx2_rtm > +#include "x86-avx2-rtm-vecs.h" > +#include "stpncpy-avx2.S" > diff --git a/sysdeps/x86_64/multiarch/stpncpy-avx2.S b/sysdeps/x86_64/multiarch/stpncpy-avx2.S > index b2f8c19143..a46a8edbe2 100644 > --- a/sysdeps/x86_64/multiarch/stpncpy-avx2.S > +++ b/sysdeps/x86_64/multiarch/stpncpy-avx2.S > @@ -3,6 +3,5 @@ > #endif > > #define USE_AS_STPCPY > -#define USE_AS_STRNCPY > -#define STRCPY STPNCPY > -#include "strcpy-avx2.S" > +#define STRNCPY STPNCPY > +#include "strncpy-avx2.S" > diff --git a/sysdeps/x86_64/multiarch/strcat-avx2-rtm.S b/sysdeps/x86_64/multiarch/strcat-avx2-rtm.S > index 637fb557c4..94d51d10bd 100644 > --- a/sysdeps/x86_64/multiarch/strcat-avx2-rtm.S > +++ b/sysdeps/x86_64/multiarch/strcat-avx2-rtm.S > @@ -1,12 +1,3 @@ > -#ifndef STRCAT > -# define STRCAT __strcat_avx2_rtm > -#endif > - > -#define ZERO_UPPER_VEC_REGISTERS_RETURN \ > - ZERO_UPPER_VEC_REGISTERS_RETURN_XTEST > - > -#define VZEROUPPER_RETURN jmp L(return_vzeroupper) > - > -#define SECTION(p) p##.avx.rtm > - > +#define STRCAT __strcat_avx2_rtm > +#include "x86-avx2-rtm-vecs.h" > #include "strcat-avx2.S" > diff --git a/sysdeps/x86_64/multiarch/strcat-avx2.S b/sysdeps/x86_64/multiarch/strcat-avx2.S > index d9b7fb2a43..3f914fa342 100644 > --- a/sysdeps/x86_64/multiarch/strcat-avx2.S > +++ b/sysdeps/x86_64/multiarch/strcat-avx2.S > @@ -16,266 +16,10 @@ > License along with the GNU C Library; if not, see > . */ > > -#include > - > -#if ISA_SHOULD_BUILD (3) > - > - > -# include > - > -# ifndef STRCAT > -# define STRCAT __strcat_avx2 > -# endif > - > -# define USE_AS_STRCAT > - > -/* Number of bytes in a vector register */ > -# define VEC_SIZE 32 > - > -# ifndef SECTION > -# define SECTION(p) p##.avx > -# endif > - > - .section SECTION(.text),"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 > - vpxor %xmm6, %xmm6, %xmm6 > - cmp $(VEC_SIZE * 3), %ecx > - ja L(fourth_vector_boundary) > - vpcmpeqb (%rdi), %ymm6, %ymm0 > - vpmovmskb %ymm0, %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 > - vpcmpeqb (%rax), %ymm6, %ymm0 > - mov $-1, %r10d > - sub %rax, %rcx > - shl %cl, %r10d > - vpmovmskb %ymm0, %edx > - and %r10d, %edx > - jnz L(exit) > - > -L(align_vec_size_start): > - vpcmpeqb VEC_SIZE(%rax), %ymm6, %ymm0 > - vpmovmskb %ymm0, %edx > - test %edx, %edx > - jnz L(exit_null_on_second_vector) > - > - vpcmpeqb (VEC_SIZE * 2)(%rax), %ymm6, %ymm1 > - vpmovmskb %ymm1, %edx > - test %edx, %edx > - jnz L(exit_null_on_third_vector) > - > - vpcmpeqb (VEC_SIZE * 3)(%rax), %ymm6, %ymm2 > - vpmovmskb %ymm2, %edx > - test %edx, %edx > - jnz L(exit_null_on_fourth_vector) > - > - vpcmpeqb (VEC_SIZE * 4)(%rax), %ymm6, %ymm3 > - vpmovmskb %ymm3, %edx > - test %edx, %edx > - jnz L(exit_null_on_fifth_vector) > - > - vpcmpeqb (VEC_SIZE * 5)(%rax), %ymm6, %ymm0 > - add $(VEC_SIZE * 4), %rax > - vpmovmskb %ymm0, %edx > - test %edx, %edx > - jnz L(exit_null_on_second_vector) > - > - vpcmpeqb (VEC_SIZE * 2)(%rax), %ymm6, %ymm1 > - vpmovmskb %ymm1, %edx > - test %edx, %edx > - jnz L(exit_null_on_third_vector) > - > - vpcmpeqb (VEC_SIZE * 3)(%rax), %ymm6, %ymm2 > - vpmovmskb %ymm2, %edx > - test %edx, %edx > - jnz L(exit_null_on_fourth_vector) > - > - vpcmpeqb (VEC_SIZE * 4)(%rax), %ymm6, %ymm3 > - vpmovmskb %ymm3, %edx > - test %edx, %edx > - jnz L(exit_null_on_fifth_vector) > - > - vpcmpeqb (VEC_SIZE * 5)(%rax), %ymm6, %ymm0 > - add $(VEC_SIZE * 4), %rax > - vpmovmskb %ymm0, %edx > - test %edx, %edx > - jnz L(exit_null_on_second_vector) > - > - vpcmpeqb (VEC_SIZE * 2)(%rax), %ymm6, %ymm1 > - vpmovmskb %ymm1, %edx > - test %edx, %edx > - jnz L(exit_null_on_third_vector) > - > - vpcmpeqb (VEC_SIZE * 3)(%rax), %ymm6, %ymm2 > - vpmovmskb %ymm2, %edx > - test %edx, %edx > - jnz L(exit_null_on_fourth_vector) > - > - vpcmpeqb (VEC_SIZE * 4)(%rax), %ymm6, %ymm3 > - vpmovmskb %ymm3, %edx > - test %edx, %edx > - jnz L(exit_null_on_fifth_vector) > - > - vpcmpeqb (VEC_SIZE * 5)(%rax), %ymm6, %ymm0 > - add $(VEC_SIZE * 4), %rax > - vpmovmskb %ymm0, %edx > - test %edx, %edx > - jnz L(exit_null_on_second_vector) > - > - vpcmpeqb (VEC_SIZE * 2)(%rax), %ymm6, %ymm1 > - vpmovmskb %ymm1, %edx > - test %edx, %edx > - jnz L(exit_null_on_third_vector) > - > - vpcmpeqb (VEC_SIZE * 3)(%rax), %ymm6, %ymm2 > - vpmovmskb %ymm2, %edx > - test %edx, %edx > - jnz L(exit_null_on_fourth_vector) > - > - vpcmpeqb (VEC_SIZE * 4)(%rax), %ymm6, %ymm3 > - vpmovmskb %ymm3, %edx > - test %edx, %edx > - jnz L(exit_null_on_fifth_vector) > - > - test $((VEC_SIZE * 4) - 1), %rax > - jz L(align_four_vec_loop) > - > - vpcmpeqb (VEC_SIZE * 5)(%rax), %ymm6, %ymm0 > - add $(VEC_SIZE * 5), %rax > - vpmovmskb %ymm0, %edx > - test %edx, %edx > - jnz L(exit) > - > - test $((VEC_SIZE * 4) - 1), %rax > - jz L(align_four_vec_loop) > - > - vpcmpeqb VEC_SIZE(%rax), %ymm6, %ymm1 > - add $VEC_SIZE, %rax > - vpmovmskb %ymm1, %edx > - test %edx, %edx > - jnz L(exit) > - > - test $((VEC_SIZE * 4) - 1), %rax > - jz L(align_four_vec_loop) > - > - vpcmpeqb VEC_SIZE(%rax), %ymm6, %ymm2 > - add $VEC_SIZE, %rax > - vpmovmskb %ymm2, %edx > - test %edx, %edx > - jnz L(exit) > - > - test $((VEC_SIZE * 4) - 1), %rax > - jz L(align_four_vec_loop) > - > - vpcmpeqb VEC_SIZE(%rax), %ymm6, %ymm3 > - add $VEC_SIZE, %rax > - vpmovmskb %ymm3, %edx > - test %edx, %edx > - jnz L(exit) > - > - add $VEC_SIZE, %rax > - > - .p2align 4 > -L(align_four_vec_loop): > - vmovaps (%rax), %ymm4 > - vpminub VEC_SIZE(%rax), %ymm4, %ymm4 > - vmovaps (VEC_SIZE * 2)(%rax), %ymm5 > - vpminub (VEC_SIZE * 3)(%rax), %ymm5, %ymm5 > - add $(VEC_SIZE * 4), %rax > - vpminub %ymm4, %ymm5, %ymm5 > - vpcmpeqb %ymm5, %ymm6, %ymm5 > - vpmovmskb %ymm5, %edx > - test %edx, %edx > - jz L(align_four_vec_loop) > - > - vpcmpeqb -(VEC_SIZE * 4)(%rax), %ymm6, %ymm0 > - sub $(VEC_SIZE * 5), %rax > - vpmovmskb %ymm0, %edx > - test %edx, %edx > - jnz L(exit_null_on_second_vector) > - > - vpcmpeqb (VEC_SIZE * 2)(%rax), %ymm6, %ymm1 > - vpmovmskb %ymm1, %edx > - test %edx, %edx > - jnz L(exit_null_on_third_vector) > - > - vpcmpeqb (VEC_SIZE * 3)(%rax), %ymm6, %ymm2 > - vpmovmskb %ymm2, %edx > - test %edx, %edx > - jnz L(exit_null_on_fourth_vector) > - > - vpcmpeqb (VEC_SIZE * 4)(%rax), %ymm6, %ymm3 > - vpmovmskb %ymm3, %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-avx2.S" > +#ifndef STRCAT > +# define STRCAT __strcat_avx2 > #endif > + > +#define USE_AS_STRCAT > +#define STRCPY STRCAT > +#include "strcpy-avx2.S" > diff --git a/sysdeps/x86_64/multiarch/strcat-strlen-avx2.S b/sysdeps/x86_64/multiarch/strcat-strlen-avx2.S > new file mode 100644 > index 0000000000..e0fc286826 > --- /dev/null > +++ b/sysdeps/x86_64/multiarch/strcat-strlen-avx2.S > @@ -0,0 +1,76 @@ > + /* Simple strlen implementation that ends at L(strcat_strlen_done). */ > + movq %rdi, %r8 > + andq $(VEC_SIZE * -1), %r8 > + VPCMPEQ (%r8), %VZERO, %VMM(0) > + vpmovmskb %VMM(0), %ecx > + shrxl %edi, %ecx, %ecx > + testl %ecx, %ecx > + jnz L(bsf_and_done_v0) > + > + VPCMPEQ VEC_SIZE(%r8), %VZERO, %VMM(0) > + vpmovmskb %VMM(0), %ecx > + leaq (VEC_SIZE)(%r8), %rdi > + testl %ecx, %ecx > + jnz L(bsf_and_done_v0) > + > + VPCMPEQ (VEC_SIZE * 1)(%rdi), %VZERO, %VMM(0) > + vpmovmskb %VMM(0), %ecx > + testl %ecx, %ecx > + jnz L(bsf_and_done_v1) > + > + VPCMPEQ (VEC_SIZE * 2)(%rdi), %VZERO, %VMM(0) > + vpmovmskb %VMM(0), %ecx > + testl %ecx, %ecx > + jnz L(bsf_and_done_v2) > + > + VPCMPEQ (VEC_SIZE * 3)(%rdi), %VZERO, %VMM(0) > + vpmovmskb %VMM(0), %ecx > + testl %ecx, %ecx > + jnz L(bsf_and_done_v3) > + > + orq $(VEC_SIZE * 4 - 1), %rdi > + .p2align 4,, 8 > +L(strlen_loop_4x_vec): > + VMOVA (VEC_SIZE * 0 + 1)(%rdi), %VMM(0) > + VPMIN (VEC_SIZE * 1 + 1)(%rdi), %VMM(0), %VMM(1) > + VMOVA (VEC_SIZE * 2 + 1)(%rdi), %VMM(2) > + VPMIN (VEC_SIZE * 3 + 1)(%rdi), %VMM(2), %VMM(3) > + VPMIN %VMM(1), %VMM(3), %VMM(3) > + VPCMPEQ %VMM(3), %VZERO, %VMM(3) > + vpmovmskb %VMM(3), %r8d > + subq $(VEC_SIZE * -4), %rdi > + testl %r8d, %r8d > + jz L(strlen_loop_4x_vec) > + > + addq $(VEC_SIZE * -4 + 1), %rdi > + > + VPCMPEQ %VMM(0), %VZERO, %VMM(0) > + vpmovmskb %VMM(0), %ecx > + testl %ecx, %ecx > + jnz L(bsf_and_done_v0) > + > + VPCMPEQ %VMM(1), %VZERO, %VMM(1) > + vpmovmskb %VMM(1), %ecx > + testl %ecx, %ecx > + jnz L(bsf_and_done_v1) > + > + VPCMPEQ %VMM(2), %VZERO, %VMM(2) > + vpmovmskb %VMM(2), %ecx > + testl %ecx, %ecx > + jnz L(bsf_and_done_v2) > + > + movl %r8d, %ecx > +L(bsf_and_done_v3): > + addq $VEC_SIZE, %rdi > +L(bsf_and_done_v2): > + bsfl %ecx, %ecx > + leaq (VEC_SIZE * 2)(%rdi, %rcx), %rdi > + jmp L(strcat_strlen_done) > + > + .p2align 4,, 4 > +L(bsf_and_done_v1): > + addq $VEC_SIZE, %rdi > +L(bsf_and_done_v0): > + bsfl %ecx, %ecx > + addq %rcx, %rdi > +L(strcat_strlen_done): > diff --git a/sysdeps/x86_64/multiarch/strcpy-avx2-rtm.S b/sysdeps/x86_64/multiarch/strcpy-avx2-rtm.S > index c2c581ecf7..fe80ffd265 100644 > --- a/sysdeps/x86_64/multiarch/strcpy-avx2-rtm.S > +++ b/sysdeps/x86_64/multiarch/strcpy-avx2-rtm.S > @@ -1,12 +1,3 @@ > -#ifndef STRCPY > -# define STRCPY __strcpy_avx2_rtm > -#endif > - > -#define ZERO_UPPER_VEC_REGISTERS_RETURN \ > - ZERO_UPPER_VEC_REGISTERS_RETURN_XTEST > - > -#define VZEROUPPER_RETURN jmp L(return_vzeroupper) > - > -#define SECTION(p) p##.avx.rtm > - > +#define STRCPY __strcpy_avx2_rtm > +#include "x86-avx2-rtm-vecs.h" > #include "strcpy-avx2.S" > diff --git a/sysdeps/x86_64/multiarch/strcpy-avx2.S b/sysdeps/x86_64/multiarch/strcpy-avx2.S > index c725834929..b87a1722d5 100644 > --- a/sysdeps/x86_64/multiarch/strcpy-avx2.S > +++ b/sysdeps/x86_64/multiarch/strcpy-avx2.S > @@ -20,984 +20,378 @@ > > #if ISA_SHOULD_BUILD (3) > > +# include > > -# ifndef USE_AS_STRCAT > -# include > - > -# ifndef STRCPY > -# define STRCPY __strcpy_avx2 > -# endif > - > -# endif > - > -/* Number of bytes in a vector register */ > # ifndef VEC_SIZE > -# define VEC_SIZE 32 > -# endif > - > -# ifndef VZEROUPPER > -# define VZEROUPPER vzeroupper > -# endif > - > -# ifndef SECTION > -# define SECTION(p) p##.avx > -# endif > - > -/* zero register */ > -#define xmmZ xmm0 > -#define ymmZ ymm0 > - > -/* mask register */ > -#define ymmM ymm1 > - > -# ifndef USE_AS_STRCAT > - > - .section SECTION(.text),"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 > - > +# include "x86-avx2-vecs.h" > # endif > > - vpxor %xmmZ, %xmmZ, %xmmZ > - > - and $((VEC_SIZE * 4) - 1), %ecx > - cmp $(VEC_SIZE * 2), %ecx > - jbe L(SourceStringAlignmentLessTwoVecSize) > - > - and $-VEC_SIZE, %rsi > - and $(VEC_SIZE - 1), %ecx > - > - vpcmpeqb (%rsi), %ymmZ, %ymmM > - vpmovmskb %ymmM, %edx > - shr %cl, %rdx > - > -# 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) > +# ifndef STRCPY > +# define STRCPY __strcpy_avx2 > # endif > - test %edx, %edx > - jnz L(CopyVecSizeTail) > > - vpcmpeqb VEC_SIZE(%rsi), %ymmZ, %ymm2 > - vpmovmskb %ymm2, %edx > + /* Use movsb in page cross case to save code size. */ > +# define USE_MOVSB_IN_PAGE_CROSS 1 > > -# ifdef USE_AS_STRNCPY > - add $VEC_SIZE, %r10 > - cmp %r10, %r8 > - jbe L(CopyTwoVecSizeCase2OrCase3) > -# endif > - test %edx, %edx > - jnz L(CopyTwoVecSize) > - > - vmovdqu (%rsi, %rcx), %ymm2 /* copy VEC_SIZE bytes */ > - vmovdqu %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 > - vmovdqa (%rsi, %rcx), %ymm2 > - vmovdqu %ymm2, (%rdi, %rcx) > - vmovdqa VEC_SIZE(%rsi, %rcx), %ymm2 > - vpcmpeqb %ymm2, %ymmZ, %ymmM > - vpmovmskb %ymmM, %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_WCSCPY > +# define VPCMPEQ vpcmpeqd > +# define VPMIN vpminud > +# define CHAR_SIZE 4 > # else > - jnz L(CopyVecSize) > +# define VPCMPEQ vpcmpeqb > +# define VPMIN vpminub > +# define CHAR_SIZE 1 > # endif > > - vmovdqu %ymm2, (%rdi, %rcx) > - vmovdqa VEC_SIZE(%rsi, %rcx), %ymm3 > - vpcmpeqb %ymm3, %ymmZ, %ymmM > - vpmovmskb %ymmM, %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 > +# define PAGE_SIZE 4096 > > - vmovdqu %ymm3, (%rdi, %rcx) > - vmovdqa VEC_SIZE(%rsi, %rcx), %ymm4 > - vpcmpeqb %ymm4, %ymmZ, %ymmM > - vpmovmskb %ymmM, %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) > +# ifdef USE_AS_STPCPY > +# define END_REG rax > # else > - jnz L(CopyVecSize) > +# define END_REG rdi, %rdx > # endif > > - vmovdqu %ymm4, (%rdi, %rcx) > - vmovdqa VEC_SIZE(%rsi, %rcx), %ymm2 > - vpcmpeqb %ymm2, %ymmZ, %ymmM > - vpmovmskb %ymmM, %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) > +# ifdef USE_AS_STRCAT > +# define PAGE_ALIGN_REG ecx > # else > - jnz L(CopyVecSize) > +# define PAGE_ALIGN_REG eax > # endif > > - vmovdqu %ymm2, (%rdi, %rcx) > - vmovdqa VEC_SIZE(%rsi, %rcx), %ymm2 > - vpcmpeqb %ymm2, %ymmZ, %ymmM > - vpmovmskb %ymmM, %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 VZERO VMM(7) > +# define VZERO_128 VMM_128(7) > > - vmovdqa VEC_SIZE(%rsi, %rcx), %ymm3 > - vmovdqu %ymm2, (%rdi, %rcx) > - vpcmpeqb %ymm3, %ymmZ, %ymmM > - vpmovmskb %ymmM, %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 > + .section SECTION(.text), "ax", @progbits > +ENTRY(STRCPY) > + vpxor %VZERO_128, %VZERO_128, %VZERO_128 > > - vmovdqu %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): > - vmovdqa (%rsi), %ymm4 > - vmovdqa VEC_SIZE(%rsi), %ymm5 > - vmovdqa (VEC_SIZE * 2)(%rsi), %ymm6 > - vmovdqa (VEC_SIZE * 3)(%rsi), %ymm7 > - vpminub %ymm5, %ymm4, %ymm2 > - vpminub %ymm7, %ymm6, %ymm3 > - vpminub %ymm2, %ymm3, %ymm3 > - vpcmpeqb %ymmM, %ymm3, %ymm3 > - vpmovmskb %ymm3, %edx > -# ifdef USE_AS_STRNCPY > - sub $(VEC_SIZE * 4), %r8 > - jbe L(UnalignedLeaveCase2OrCase3) > -# endif > - test %edx, %edx > - jnz L(UnalignedFourVecSizeLeave) > - > -L(UnalignedFourVecSizeLoop_start): > - add $(VEC_SIZE * 4), %rdi > - add $(VEC_SIZE * 4), %rsi > - vmovdqu %ymm4, -(VEC_SIZE * 4)(%rdi) > - vmovdqa (%rsi), %ymm4 > - vmovdqu %ymm5, -(VEC_SIZE * 3)(%rdi) > - vmovdqa VEC_SIZE(%rsi), %ymm5 > - vpminub %ymm5, %ymm4, %ymm2 > - vmovdqu %ymm6, -(VEC_SIZE * 2)(%rdi) > - vmovdqa (VEC_SIZE * 2)(%rsi), %ymm6 > - vmovdqu %ymm7, -VEC_SIZE(%rdi) > - vmovdqa (VEC_SIZE * 3)(%rsi), %ymm7 > - vpminub %ymm7, %ymm6, %ymm3 > - vpminub %ymm2, %ymm3, %ymm3 > - vpcmpeqb %ymmM, %ymm3, %ymm3 > - vpmovmskb %ymm3, %edx > -# ifdef USE_AS_STRNCPY > - sub $(VEC_SIZE * 4), %r8 > - jbe L(UnalignedLeaveCase2OrCase3) > -# endif > - test %edx, %edx > - jz L(UnalignedFourVecSizeLoop_start) > - > -L(UnalignedFourVecSizeLeave): > - vpcmpeqb %ymm4, %ymmZ, %ymmM > - vpmovmskb %ymmM, %edx > - test %edx, %edx > - jnz L(CopyVecSizeUnaligned_0) > - > - vpcmpeqb %ymm5, %ymmZ, %ymmM > - vpmovmskb %ymmM, %ecx > - test %ecx, %ecx > - jnz L(CopyVecSizeUnaligned_16) > - > - vpcmpeqb %ymm6, %ymmZ, %ymmM > - vpmovmskb %ymmM, %edx > - test %edx, %edx > - jnz L(CopyVecSizeUnaligned_32) > - > - vpcmpeqb %ymm7, %ymmZ, %ymmM > - vpmovmskb %ymmM, %ecx > - bsf %ecx, %edx > - vmovdqu %ymm4, (%rdi) > - vmovdqu %ymm5, VEC_SIZE(%rdi) > - vmovdqu %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 > - vmovdqu %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) > +# ifdef USE_AS_STRCAT > + movq %rdi, %rax > +# include "strcat-strlen-avx2.S" > # endif > > -/* If source address alignment == destination address alignment */ > - > -L(SourceStringAlignmentLessTwoVecSize): > - vmovdqu (%rsi), %ymm3 > - vmovdqu VEC_SIZE(%rsi), %ymm2 > - vpcmpeqb %ymm3, %ymmZ, %ymmM > - vpmovmskb %ymmM, %edx > - > -# ifdef USE_AS_STRNCPY > -# if defined USE_AS_STPCPY || defined USE_AS_STRCAT > - cmp $VEC_SIZE, %r8 > -# else > - cmp $(VEC_SIZE + 1), %r8 > -# endif > - jbe L(CopyVecSizeTail1Case2OrCase3) > + 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): > +# if !defined USE_AS_STPCPY && !defined USE_AS_STRCAT > + movq %rdi, %rax > # endif > - test %edx, %edx > - jnz L(CopyVecSizeTail1) > - > - vmovdqu %ymm3, (%rdi) > - vpcmpeqb %ymm2, %ymmZ, %ymmM > - vpmovmskb %ymmM, %edx > - > -# ifdef USE_AS_STRNCPY > -# if defined USE_AS_STPCPY || defined USE_AS_STRCAT > - cmp $(VEC_SIZE * 2), %r8 > -# else > - cmp $((VEC_SIZE * 2) + 1), %r8 > -# endif > - jbe L(CopyTwoVecSize1Case2OrCase3) > -# endif > - test %edx, %edx > - jnz L(CopyTwoVecSize1) > - > - and $-VEC_SIZE, %rsi > - and $(VEC_SIZE - 1), %ecx > - jmp L(UnalignVecSizeBoth) > + VMOVU (%rsi), %VMM(0) > + VPCMPEQ %VMM(0), %VZERO, %VMM(6) > + vpmovmskb %VMM(6), %ecx > > -/*------End of main part with loops---------------------*/ > + testl %ecx, %ecx > + jz L(more_1x_vec) > > -/* Case1 */ > + /* No longer need ymm registers so just vzeroupper so it doesn't > + need to be duplicated at each return statement. */ > + COND_VZEROUPPER > > -# 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) > + xorl %edx, %edx > + bsfl %ecx, %edx > # 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 > -L(return_vzeroupper): > - ZERO_UPPER_VEC_REGISTERS_RETURN > - > - .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 > - vmovdqu %ymm4, (%rdi) > - add $((VEC_SIZE * 4) - 1), %r8 > - sub %rdx, %r8 > - lea 1(%rdi, %rdx), %rdi > - jmp L(StrncpyFillTailWithZero) > -# else > - jmp L(CopyVecSizeExit) > -# endif > - > - .p2align 4 > -L(CopyVecSizeUnaligned_16): > - bsf %ecx, %edx > - vmovdqu %ymm4, (%rdi) > -# if defined USE_AS_STRNCPY && !defined USE_AS_STRCAT > -# ifdef USE_AS_STPCPY > - lea VEC_SIZE(%rdi, %rdx), %rax > -# endif > - vmovdqu %ymm5, VEC_SIZE(%rdi) > - add $((VEC_SIZE * 3) - 1), %r8 > - sub %rdx, %r8 > - lea (VEC_SIZE + 1)(%rdi, %rdx), %rdi > - jmp L(StrncpyFillTailWithZero) > + leaq (%rdi, %rdx), %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 ecx != 0 and cx == 0, then match must be upper 16 > + bits so we use L(copy_16_31). */ > + testw %cx, %cx > + jz L(copy_16_31) > + > + testb %cl, %cl > + jz L(copy_8_15) > +# ifdef USE_AS_WCSCPY > + vmovd %xmm0, (%rdi) > + movl $0, (%END_REG) > + ret > # else > - add $VEC_SIZE, %rsi > - add $VEC_SIZE, %rdi > - jmp L(CopyVecSizeExit) > -# endif > - > - .p2align 4 > -L(CopyVecSizeUnaligned_32): > - bsf %edx, %edx > - vmovdqu %ymm4, (%rdi) > - vmovdqu %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 > - vmovdqu %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) > + testb $0x7, %cl > + jz L(copy_4_7) > + > + testl %edx, %edx > + jz L(set_null_term) > + vmovd %xmm0, %ecx > + movw %cx, (%rdi) > + > + .p2align 4,, 2 > +L(set_null_term): > + movb $0, (%END_REG) > + ret > + > + .p2align 4,, 12 > +L(copy_4_7): > + movl -3(%rsi, %rdx), %ecx > + vmovd %xmm0, (%rdi) > + movl %ecx, -3(%END_REG) > + ret > +# endif > + > + .p2align 4,, 10 > +L(copy_16_31): > + VMOVU -(16 - CHAR_SIZE)(%rsi, %rdx), %xmm1 > + VMOVU %xmm0, (%rdi) > + VMOVU %xmm1, -(16 - CHAR_SIZE)(%END_REG) > + ret > + > + .p2align 4,, 10 > +L(copy_8_15): > +# ifdef USE_AS_WCSCPY > + movl -(8 - CHAR_SIZE)(%rsi, %rdx), %ecx > # else > - add $(VEC_SIZE * 2), %rsi > - add $(VEC_SIZE * 2), %rdi > - jmp L(CopyVecSizeExit) > -# endif > - > -# ifdef USE_AS_STRNCPY > -# ifndef USE_AS_STRCAT > - .p2align 4 > -L(CopyVecSizeUnalignedVec6): > - vmovdqu %ymm6, (%rdi, %rcx) > - jmp L(CopyVecSizeVecExit) > - > - .p2align 4 > -L(CopyVecSizeUnalignedVec5): > - vmovdqu %ymm5, (%rdi, %rcx) > - jmp L(CopyVecSizeVecExit) > - > - .p2align 4 > -L(CopyVecSizeUnalignedVec4): > - vmovdqu %ymm4, (%rdi, %rcx) > - jmp L(CopyVecSizeVecExit) > - > - .p2align 4 > -L(CopyVecSizeUnalignedVec3): > - vmovdqu %ymm3, (%rdi, %rcx) > - jmp L(CopyVecSizeVecExit) > -# 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) > -# 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 > -# endif > -# if defined USE_AS_STRNCPY && !defined USE_AS_STRCAT > - sub $2, %r8 > - lea 2(%rdi), %rdi > - jnz L(StrncpyFillTailWithZero) > -# endif > - VZEROUPPER_RETURN > - > - .p2align 4 > -L(Exit2): > - movzwl (%rsi), %ecx > - mov %cx, (%rdi) > - movb $0, 2(%rdi) > -# 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) > -# endif > - VZEROUPPER_RETURN > - > - .p2align 4 > -L(Exit3): > - mov (%rsi), %edx > - mov %edx, (%rdi) > + movq -(8 - CHAR_SIZE)(%rsi, %rdx), %rcx > +# endif > + vmovq %xmm0, (%rdi) > + movq %rcx, -(8 - CHAR_SIZE)(%END_REG) > + ret > + > + > + .p2align 4,, 8 > +L(more_1x_vec): > +# if defined USE_AS_STPCPY || defined USE_AS_STRCAT > + VMOVU %VMM(0), (%rdi) > +# endif > + subq %rsi, %rdi > + orq $(VEC_SIZE - 1), %rsi > + addq %rsi, %rdi > + VMOVA 1(%rsi), %VMM(1) > + > + /* Try and order stores after as many loads as is reasonable to > + avoid potential false dependencies. */ > +# if !defined USE_AS_STPCPY && !defined USE_AS_STRCAT > + VMOVU %VMM(0), (%rax) > +# endif > + VPCMPEQ %VMM(1), %VZERO, %VMM(6) > + vpmovmskb %VMM(6), %ecx > + testl %ecx, %ecx > + jnz L(ret_vec_x1) > + > + VMOVA (VEC_SIZE + 1)(%rsi), %VMM(2) > + VMOVU %VMM(1), 1(%rdi) > + > + VPCMPEQ %VMM(2), %VZERO, %VMM(6) > + vpmovmskb %VMM(6), %ecx > + testl %ecx, %ecx > + jnz L(ret_vec_x2) > + > + VMOVA (VEC_SIZE * 2 + 1)(%rsi), %VMM(3) > + VMOVU %VMM(2), (VEC_SIZE + 1)(%rdi) > + > + VPCMPEQ %VMM(3), %VZERO, %VMM(6) > + vpmovmskb %VMM(6), %ecx > + testl %ecx, %ecx > + jnz L(ret_vec_x3) > + > + VMOVA (VEC_SIZE * 3 + 1)(%rsi), %VMM(4) > + VMOVU %VMM(3), (VEC_SIZE * 2 + 1)(%rdi) > + VPCMPEQ %VMM(4), %VZERO, %VMM(6) > + vpmovmskb %VMM(6), %edx > + testl %edx, %edx > + jnz L(ret_vec_x4) > + > + VMOVU %VMM(4), (VEC_SIZE * 3 + 1)(%rdi) > + > + /* Subtract rsi from rdi before aligning. Adding back rsi will > + get proper rdi (dst) for new src. */ > + subq %rsi, %rdi > + incq %rsi > + orq $(VEC_SIZE * 4 - 1), %rsi > + > + /* Do first half of loop ahead of time so loop can just start by > + storing. */ > + VMOVA (VEC_SIZE * 0 + 1)(%rsi), %VMM(0) > + VMOVA (VEC_SIZE * 1 + 1)(%rsi), %VMM(1) > + VMOVA (VEC_SIZE * 2 + 1)(%rsi), %VMM(2) > + VMOVA (VEC_SIZE * 3 + 1)(%rsi), %VMM(3) > + > + VPMIN %VMM(0), %VMM(1), %VMM(4) > + VPMIN %VMM(2), %VMM(3), %VMM(6) > + VPMIN %VMM(4), %VMM(6), %VMM(6) > + VPCMPEQ %VMM(6), %VZERO, %VMM(6) > + vpmovmskb %VMM(6), %edx > + addq %rsi, %rdi > + > + testl %edx, %edx > + jnz L(loop_4x_done) > + > + .p2align 4,, 11 > +L(loop_4x_vec): > + > + VMOVU %VMM(0), (VEC_SIZE * 0 + 1)(%rdi) > + VMOVU %VMM(1), (VEC_SIZE * 1 + 1)(%rdi) > + subq $(VEC_SIZE * -4), %rsi > + VMOVU %VMM(2), (VEC_SIZE * 2 + 1)(%rdi) > + VMOVU %VMM(3), (VEC_SIZE * 3 + 1)(%rdi) > + > + > + VMOVA (VEC_SIZE * 0 + 1)(%rsi), %VMM(0) > + VMOVA (VEC_SIZE * 1 + 1)(%rsi), %VMM(1) > + VMOVA (VEC_SIZE * 2 + 1)(%rsi), %VMM(2) > + VMOVA (VEC_SIZE * 3 + 1)(%rsi), %VMM(3) > + > + VPMIN %VMM(0), %VMM(1), %VMM(4) > + VPMIN %VMM(2), %VMM(3), %VMM(6) > + VPMIN %VMM(4), %VMM(6), %VMM(6) > + VPCMPEQ %VMM(6), %VZERO, %VMM(6) > + > + vpmovmskb %VMM(6), %edx > + subq $(VEC_SIZE * -4), %rdi > + testl %edx, %edx > + jz L(loop_4x_vec) > + > +L(loop_4x_done): > + VPCMPEQ %VMM(0), %VZERO, %VMM(6) > + vpmovmskb %VMM(6), %ecx > + testl %ecx, %ecx > + jnz L(ret_vec_x1) > + VMOVU %VMM(0), (VEC_SIZE * 0 + 1)(%rdi) > + > + VPCMPEQ %VMM(1), %VZERO, %VMM(6) > + vpmovmskb %VMM(6), %ecx > + testl %ecx, %ecx > + jnz L(ret_vec_x2) > + VMOVU %VMM(1), (VEC_SIZE * 1 + 1)(%rdi) > + > + VPCMPEQ %VMM(2), %VZERO, %VMM(6) > + vpmovmskb %VMM(6), %ecx > + testl %ecx, %ecx > + jnz L(ret_vec_x3) > + VMOVU %VMM(2), (VEC_SIZE * 2 + 1)(%rdi) > +L(ret_vec_x4): > + bsfl %edx, %edx > + VMOVU ((VEC_SIZE * 3 + 1)-(VEC_SIZE - CHAR_SIZE))(%rsi, %rdx), %VMM(1) > + VMOVU %VMM(1), ((VEC_SIZE * 3 + 1)-(VEC_SIZE - CHAR_SIZE))(%rdi, %rdx) > # 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 (VEC_SIZE * 3 + 1)(%rdx, %rdi), %rax > # endif > +L(return_end): > VZEROUPPER_RETURN > > - .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): > + bsfl %ecx, %ecx > + VMOVU (1 -(VEC_SIZE - CHAR_SIZE))(%rsi, %rcx), %VMM(1) > + VMOVU %VMM(1), (1 -(VEC_SIZE - CHAR_SIZE))(%rdi, %rcx) > # 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 1(%rcx, %rdi), %rax > # endif > - VZEROUPPER_RETURN > - > - .p2align 4 > -L(Exit8_15): > - mov (%rsi), %rcx > - mov -7(%rsi, %rdx), %r9 > - mov %rcx, (%rdi) > - mov %r9, -7(%rdi, %rdx) > -# 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) > -# endif > - VZEROUPPER_RETURN > +L(return_vzeroupper): > + ZERO_UPPER_VEC_REGISTERS_RETURN > > - .p2align 4 > -L(Exit16_31): > - vmovdqu (%rsi), %xmm2 > - vmovdqu -15(%rsi, %rdx), %xmm3 > - vmovdqu %xmm2, (%rdi) > - vmovdqu %xmm3, -15(%rdi, %rdx) > + .p2align 4,, 8 > +L(ret_vec_x2): > + bsfl %ecx, %ecx > + VMOVU ((VEC_SIZE + 1)-(VEC_SIZE - CHAR_SIZE))(%rsi, %rcx), %VMM(1) > + VMOVU %VMM(1), ((VEC_SIZE + 1)-(VEC_SIZE - CHAR_SIZE))(%rdi, %rcx) > # 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 * 1 + 1)(%rcx, %rdi), %rax > # endif > VZEROUPPER_RETURN > > - .p2align 4 > -L(Exit32_63): > - vmovdqu (%rsi), %ymm2 > - vmovdqu -31(%rsi, %rdx), %ymm3 > - vmovdqu %ymm2, (%rdi) > - vmovdqu %ymm3, -31(%rdi, %rdx) > + .p2align 4,, 8 > +L(ret_vec_x3): > + bsfl %ecx, %ecx > + VMOVU ((VEC_SIZE * 2 + 1)-(VEC_SIZE - CHAR_SIZE))(%rsi, %rcx), %VMM(1) > + VMOVU %VMM(1), ((VEC_SIZE * 2 + 1)-(VEC_SIZE - CHAR_SIZE))(%rdi, %rcx) > # 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 + 1)(%rcx, %rdi), %rax > # endif > VZEROUPPER_RETURN > > -# ifdef USE_AS_STRNCPY > > - .p2align 4 > -L(StrncpyExit1): > - movzbl (%rsi), %edx > - mov %dl, (%rdi) > + .p2align 4,, 4 > +L(page_cross): > + movq %rsi, %rcx > + andq $(VEC_SIZE * -1), %rcx > + > + VPCMPEQ (%rcx), %VZERO, %VMM(6) > + vpmovmskb %VMM(6), %ecx > + shrxl %esi, %ecx, %ecx > +# if USE_MOVSB_IN_PAGE_CROSS > + /* Optimizing more aggressively 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. */ > + shll $CHAR_SIZE, %ecx > + jz L(page_cross_continue) > + bsfl %ecx, %ecx > +# if !defined USE_AS_STPCPY && !defined USE_AS_STRCAT > + movq %rdi, %rax > +# endif > + rep movsb > # ifdef USE_AS_STPCPY > - lea 1(%rdi), %rax > -# endif > -# ifdef USE_AS_STRCAT > - movb $0, 1(%rdi) > + leaq -CHAR_SIZE(%rdi), %rax > # endif > - VZEROUPPER_RETURN > > - .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) > -# endif > VZEROUPPER_RETURN > > - .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 > - VZEROUPPER_RETURN > - > - .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 > - VZEROUPPER_RETURN > - > - .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 > - VZEROUPPER_RETURN > - > - .p2align 4 > -L(StrncpyExit17_32): > - vmovdqu (%rsi), %xmm2 > - vmovdqu -16(%rsi, %r8), %xmm3 > - vmovdqu %xmm2, (%rdi) > - vmovdqu %xmm3, -16(%rdi, %r8) > -# ifdef USE_AS_STPCPY > - lea (%rdi, %r8), %rax > -# endif > -# ifdef USE_AS_STRCAT > - movb $0, (%rdi, %r8) > -# endif > - VZEROUPPER_RETURN > - > - .p2align 4 > -L(StrncpyExit33_64): > - /* 0/32, 31/16 */ > - vmovdqu (%rsi), %ymm2 > - vmovdqu -VEC_SIZE(%rsi, %r8), %ymm3 > - vmovdqu %ymm2, (%rdi) > - vmovdqu %ymm3, -VEC_SIZE(%rdi, %r8) > -# ifdef USE_AS_STPCPY > - lea (%rdi, %r8), %rax > -# endif > -# ifdef USE_AS_STRCAT > - movb $0, (%rdi, %r8) > -# endif > - VZEROUPPER_RETURN > - > - .p2align 4 > -L(StrncpyExit65): > - /* 0/32, 32/32, 64/1 */ > - vmovdqu (%rsi), %ymm2 > - vmovdqu 32(%rsi), %ymm3 > - mov 64(%rsi), %cl > - vmovdqu %ymm2, (%rdi) > - vmovdqu %ymm3, 32(%rdi) > - mov %cl, 64(%rdi) > -# ifdef USE_AS_STPCPY > - lea 65(%rdi), %rax > -# endif > -# ifdef USE_AS_STRCAT > - movb $0, 65(%rdi) > -# endif > - VZEROUPPER_RETURN > +# else > + testl %ecx, %ecx > + jz L(page_cross_continue) > > + /* 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. */ > # ifndef USE_AS_STRCAT > - > - .p2align 4 > -L(Fill1): > - mov %dl, (%rdi) > - VZEROUPPER_RETURN > - > - .p2align 4 > -L(Fill2): > - mov %dx, (%rdi) > - VZEROUPPER_RETURN > - > - .p2align 4 > -L(Fill3_4): > - mov %dx, (%rdi) > - mov %dx, -2(%rdi, %r8) > - VZEROUPPER_RETURN > - > - .p2align 4 > -L(Fill5_8): > - mov %edx, (%rdi) > - mov %edx, -4(%rdi, %r8) > - VZEROUPPER_RETURN > - > - .p2align 4 > -L(Fill9_16): > - mov %rdx, (%rdi) > - mov %rdx, -8(%rdi, %r8) > - VZEROUPPER_RETURN > - > - .p2align 4 > -L(Fill17_32): > - vmovdqu %xmmZ, (%rdi) > - vmovdqu %xmmZ, -16(%rdi, %r8) > - VZEROUPPER_RETURN > - > - .p2align 4 > -L(CopyVecSizeUnalignedVec2): > - vmovdqu %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) > - > - vmovdqu %ymmZ, (%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): > - vmovdqa %ymmZ, (%rdi) > - vmovdqa %ymmZ, VEC_SIZE(%rdi) > - vmovdqa %ymmZ, (VEC_SIZE * 2)(%rdi) > - vmovdqa %ymmZ, (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) > - vmovdqa %ymmZ, (%rdi) > - vmovdqa %ymmZ, VEC_SIZE(%rdi) > - add $(VEC_SIZE * 2), %rdi > - sub $VEC_SIZE, %r8 > - jl L(StrncpyFillExit) > - vmovdqa %ymmZ, (%rdi) > - add $VEC_SIZE, %rdi > - jmp L(Fill) > - > - .p2align 4 > -L(StrncpyFillLessTwoVecSize): > - add $VEC_SIZE, %r8 > - jl L(StrncpyFillExit) > - vmovdqa %ymmZ, (%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) > - VZEROUPPER_RETURN > - > -/* end of ifndef USE_AS_STRCAT */ > + xorl %edx, %edx > # 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) > - vmovdqu %ymm4, (%rdi) > - sub $VEC_SIZE, %r8 > - jb L(CopyVecSizeCase3) > - vmovdqu %ymm5, VEC_SIZE(%rdi) > - sub $VEC_SIZE, %r8 > - jb L(CopyVecSizeCase3) > - vmovdqu %ymm6, (VEC_SIZE * 2)(%rdi) > - sub $VEC_SIZE, %r8 > - jb L(CopyVecSizeCase3) > - vmovdqu %ymm7, (VEC_SIZE * 3)(%rdi) > + bsfl %ecx, %edx > # ifdef USE_AS_STPCPY > - lea (VEC_SIZE * 4)(%rdi), %rax > -# endif > -# ifdef USE_AS_STRCAT > - movb $0, (VEC_SIZE * 4)(%rdi) > + leaq (%rdi, %rdx), %rax > +# elif !defined USE_AS_STRCAT > + movq %rdi, %rax > # endif > - VZEROUPPER_RETURN > > - .p2align 4 > -L(UnalignedFourVecSizeLeaveCase2): > - xor %ecx, %ecx > - vpcmpeqb %ymm4, %ymmZ, %ymmM > - vpmovmskb %ymmM, %edx > - add $(VEC_SIZE * 3), %r8 > - jle L(CopyVecSizeCase2OrCase3) > - test %edx, %edx > -# ifndef USE_AS_STRCAT > - jnz L(CopyVecSizeUnalignedVec4) > -# else > - jnz L(CopyVecSize) > -# endif > - vpcmpeqb %ymm5, %ymmZ, %ymmM > - vpmovmskb %ymmM, %edx > - vmovdqu %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 > + /* vzeroupper early to avoid duplicating at each return. */ > + COND_VZEROUPPER > > - vpcmpeqb %ymm6, %ymmZ, %ymmM > - vpmovmskb %ymmM, %edx > - vmovdqu %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 > + testw %cx, %cx > + jz L(page_cross_copy_16_31) > > - vpcmpeqb %ymm7, %ymmZ, %ymmM > - vpmovmskb %ymmM, %edx > - vmovdqu %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 > - VZEROUPPER_RETURN > - > - .p2align 4 > -L(ExitZero): > -# ifndef USE_AS_STRCAT > - mov %rdi, %rax > -# endif > - VZEROUPPER_RETURN > + testb %cl, %cl > + jz L(page_cross_copy_8_15) > > -# endif > + testl $0x7, %cl > + jz L(page_cross_copy_4_7) > > -# ifndef USE_AS_STRCAT > -END (STRCPY) > -# else > -END (STRCAT) > -# endif > + testl %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,, 4 > +L(page_cross_copy_4_7): > + movl (%rsi), %ecx > + movl -3(%rsi, %rdx), %esi > + movl %ecx, (%rdi) > + movl %esi, -3(%END_REG) > + ret > + > + .p2align 4,, 4 > +L(page_cross_copy_8_15): > + movq (%rsi), %rcx > + movq -7(%rsi, %rdx), %rsi > + movq %rcx, (%rdi) > + movq %rsi, -7(%END_REG) > + ret > + > + > + .p2align 4,, 3 > +L(page_cross_copy_16_31): > + VMOVU (%rsi), %xmm0 > + VMOVU -15(%rsi, %rdx), %xmm1 > + VMOVU %xmm0, (%rdi) > + VMOVU %xmm1, -15(%END_REG) > + ret > +# endif > + > +END(STRCPY) > #endif > diff --git a/sysdeps/x86_64/multiarch/strncat-avx2-rtm.S b/sysdeps/x86_64/multiarch/strncat-avx2-rtm.S > index 0dcea18dbb..2bbdbb91ab 100644 > --- a/sysdeps/x86_64/multiarch/strncat-avx2-rtm.S > +++ b/sysdeps/x86_64/multiarch/strncat-avx2-rtm.S > @@ -1,3 +1,3 @@ > -#define USE_AS_STRNCAT > -#define STRCAT __strncat_avx2_rtm > -#include "strcat-avx2-rtm.S" > +#define STRNCAT __strncat_avx2_rtm > +#include "x86-avx2-rtm-vecs.h" > +#include "strncat-avx2.S" > diff --git a/sysdeps/x86_64/multiarch/strncat-avx2.S b/sysdeps/x86_64/multiarch/strncat-avx2.S > index 52ecbca943..99d094af63 100644 > --- a/sysdeps/x86_64/multiarch/strncat-avx2.S > +++ b/sysdeps/x86_64/multiarch/strncat-avx2.S > @@ -1,7 +1,472 @@ > -#ifndef STRNCAT > -# define STRNCAT __strncat_avx2 > -#endif > +/* strncat with AVX2 > + 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 (3) > + > +# include > + > +# ifndef VEC_SIZE > +# include "x86-avx2-vecs.h" > +# endif > + > +# ifndef STRNCAT > +# define STRNCAT __strncat_avx2 > +# endif > + > + > + /* Use movsb in page cross case to save code size. */ > +# define USE_MOVSB_IN_PAGE_CROSS 1 > + > +# ifdef USE_AS_WCSCPY > +# define VPCMPEQ vpcmpeqd > +# define VPMIN vpminud > +# define CHAR_SIZE 4 > +# else > +# define VPCMPEQ vpcmpeqb > +# define VPMIN vpminub > +# define CHAR_SIZE 1 > +# endif > + > +# include "strncpy-or-cat-overflow-def.h" > + > +# define PAGE_SIZE 4096 > + > +# define VZERO VMM(7) > +# define VZERO_128 VMM_128(7) > + > + .section SECTION(.text), "ax", @progbits > +ENTRY(STRNCAT) > + /* Filter zero length strings and very long strings. Zero > + length strings just return, very long strings are handled by > + using the non-length variant {wcs|str}cat. */ > +# ifdef USE_AS_WCSCPY > + decq %rdx > + movq %rdx, %rcx > + shr $56, %rcx > + jnz L(zero_len) > + salq $2, %rdx > +# else > + decq %rdx > + /* `dec` can macrofuse with `jl`. If the flag needs to become > + `jb` replace `dec` with `sub`. */ > + jl L(zero_len) > +# endif > + movq %rdi, %rax > + vpxor %VZERO_128, %VZERO_128, %VZERO_128 > + > +# include "strcat-strlen-avx2.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) > + VPCMPEQ %VMM(0), %VZERO, %VMM(6) > + vpmovmskb %VMM(6), %ecx > + > + cmpq $VEC_SIZE, %rdx > + /* `jb` because length rdx is now length - 1. */ > + jb L(less_1x_vec) > + > + testl %ecx, %ecx > + jz L(more_1x_vec) > + > + /* Hoist this to save code size. */ > + COND_VZEROUPPER > + bsfl %ecx, %edx > + > + /* 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 ecx != 0 and cx == 0, then match must be upper 16 > + bits so we use L(copy_16_31). */ > + testw %cx, %cx > + jz L(copy_16_31) > + > + .p2align 4,, 2 > +L(copy_less_16): > + testb %cl, %cl > + jz L(copy_8_15) > + > +# ifndef USE_AS_WCSCPY > + testb $0x7, %cl > + jz L(copy_4_7) > + > + vmovd %xmm0, %ecx > + testl %edx, %edx > + jz L(set_null_term) > + movw %cx, (%rdi) > + movzbl (%rsi, %rdx), %ecx > +L(set_null_term): > + movb %cl, (%rdi, %rdx) > + ret > + > + .p2align 4,, 11 > +L(copy_4_7): > +# endif > + movl -(4 - CHAR_SIZE)(%rsi, %rdx), %ecx > + vmovd %xmm0, (%rdi) > + movl %ecx, -(4 - CHAR_SIZE)(%rdi, %rdx) > + ret > + > + > + .p2align 4,, 4 > +L(less_1x_vec): > + btsl %edx, %ecx > + COND_VZEROUPPER > + /* edx already a dependency. */ > + bsfl %ecx, %edx > + testw %cx, %cx > + jnz L(copy_less_16) > + > + .p2align 4,, 10 > +L(copy_16_31): > + VMOVU -(16 - CHAR_SIZE)(%rsi, %rdx), %xmm1 > + VMOVU %xmm0, (%rdi) > + VMOVU %xmm1, -(16 - CHAR_SIZE)(%rdi, %rdx) > + ret > + > + .p2align 4,, 10 > +L(copy_8_15): > + movq -(8 - CHAR_SIZE)(%rsi, %rdx), %rcx > + vmovq %xmm0, (%rdi) > + movq %rcx, -(8 - CHAR_SIZE)(%rdi, %rdx) > + ret > + > + .p2align 4,, 8 > + .p2align 6,, 14 > +L(more_1x_vec): > + VMOVU %VMM(0), (%rdi) > + > + /* Align rsi (src) and just rdx/rdi (length/dst). */ > + addq %rsi, %rdx > + subq %rsi, %rdi > + orq $(VEC_SIZE - 1), %rsi > + incq %rsi > + addq %rsi, %rdi > +L(loop_last_4x_vec): > + subq %rsi, %rdx > +L(last_4x_vec): > + VMOVA 0(%rsi), %VMM(1) > + VPCMPEQ %VMM(1), %VZERO, %VMM(6) > + vpmovmskb %VMM(6), %ecx > + > + > + cmpq $(VEC_SIZE * 2), %rdx > + jae L(more_2x_vec) > +L(last_2x_vec): > + tzcnt %ecx, %ecx > + cmpl %ecx, %edx > + jb L(ret_vec_x1_len) > + > + cmpl $VEC_SIZE, %ecx > + jnz L(ret_vec_x1) > + > + VMOVA (VEC_SIZE + 0)(%rsi), %VMM(2) > + VMOVU %VMM(1), 0(%rdi) > + > + VPCMPEQ %VMM(2), %VZERO, %VMM(6) > + vpmovmskb %VMM(6), %ecx > +L(ret_vec_x2_len): > + /* btsl will automatically mask lower VEC_SIZE - 1 bits from > + edx. */ > + btsl %edx, %ecx > + .p2align 4,, 3 > +L(ret_vec_x2): > + bsfl %ecx, %ecx > + VMOVU ((VEC_SIZE + 0)-(VEC_SIZE - CHAR_SIZE))(%rsi, %rcx), %VMM(1) > + VMOVU %VMM(1), ((VEC_SIZE + 0)-(VEC_SIZE - CHAR_SIZE))(%rdi, %rcx) > +L(return_vzeroupper): > + ZERO_UPPER_VEC_REGISTERS_RETURN > + > + > + .p2align 4,, 12 > +L(ret_vec_x1_len): > + movl %edx, %ecx > +L(ret_vec_x1): > + VMOVU (0 -(VEC_SIZE - CHAR_SIZE))(%rsi, %rcx), %VMM(1) > + VMOVU %VMM(1), (0 -(VEC_SIZE - CHAR_SIZE))(%rdi, %rcx) > + VZEROUPPER_RETURN > + > + .p2align 4,, 8 > +L(ret_vec_x3_len): > + btsl %edx, %ecx > +L(ret_vec_x3): > + bsfl %ecx, %ecx > + VMOVU ((VEC_SIZE * 2 + 0)-(VEC_SIZE - CHAR_SIZE))(%rsi, %rcx), %VMM(1) > + VMOVU %VMM(1), ((VEC_SIZE * 2 + 0)-(VEC_SIZE - CHAR_SIZE))(%rdi, %rcx) > + VZEROUPPER_RETURN > + > + .p2align 4,, 8 > + .p2align 6,, 14 > +L(more_2x_vec): > + /* L(ret_vec_x1) expects ecx to have position of first match so > + test with bsf. */ > + bsfl %ecx, %ecx > + jnz L(ret_vec_x1) > + > + VMOVA (VEC_SIZE + 0)(%rsi), %VMM(2) > + VMOVU %VMM(1), 0(%rdi) > + > + VPCMPEQ %VMM(2), %VZERO, %VMM(6) > + vpmovmskb %VMM(6), %ecx > + testl %ecx, %ecx > + jnz L(ret_vec_x2) > + > + > + VMOVA (VEC_SIZE * 2 + 0)(%rsi), %VMM(3) > + VMOVU %VMM(2), (VEC_SIZE + 0)(%rdi) > + > + VPCMPEQ %VMM(3), %VZERO, %VMM(6) > + vpmovmskb %VMM(6), %ecx > > -#define USE_AS_STRNCAT > -#define STRCAT STRNCAT > -#include "strcat-avx2.S" > + /* Check if length is greater than 4x VEC. */ > + addq $(VEC_SIZE * -4), %rdx > + jbe L(more_4x_vec) > + > + /* Check if length was between [VEC_SIZE * 2 + 1, VEC_SIZE * 3]. > + */ > + cmpl $((VEC_SIZE * 3 - 1)-(VEC_SIZE * 4)), %edx > + jle L(ret_vec_x3_len) > + > +L(last_vec): > + testl %ecx, %ecx > + jnz L(ret_vec_x3) > + > + VMOVA (VEC_SIZE * 3 + 0)(%rsi), %VMM(4) > + VMOVU %VMM(3), (VEC_SIZE * 2 + 0)(%rdi) > + VPCMPEQ %VMM(4), %VZERO, %VMM(6) > + vpmovmskb %VMM(6), %ecx > +L(ret_vec_x4_len): > + btsl %edx, %ecx > +L(ret_vec_x4): > + bsfl %ecx, %ecx > + VMOVU ((VEC_SIZE * 3 + 0)-(VEC_SIZE - CHAR_SIZE))(%rsi, %rcx), %VMM(1) > + VMOVU %VMM(1), ((VEC_SIZE * 3 + 0)-(VEC_SIZE - CHAR_SIZE))(%rdi, %rcx) > + VZEROUPPER_RETURN > + > + > + > + > + .p2align 4,, 8 > + .p2align 6,, 10 > +L(more_4x_vec): > + testl %ecx, %ecx > + jnz L(ret_vec_x3) > + > + VMOVA (VEC_SIZE * 3 + 0)(%rsi), %VMM(4) > + VMOVU %VMM(3), (VEC_SIZE * 2 + 0)(%rdi) > + VPCMPEQ %VMM(4), %VZERO, %VMM(6) > + vpmovmskb %VMM(6), %ecx > + testl %ecx, %ecx > + jnz L(ret_vec_x4) > + > + VMOVU %VMM(4), (VEC_SIZE * 3 + 0)(%rdi) > + > + subq $-(VEC_SIZE * 4), %rdi > + subq $-(VEC_SIZE * 4), %rsi > + /* Recheck length before aligning. */ > + cmpq $(VEC_SIZE * 4 - 1), %rdx > + jbe L(last_4x_vec) > + > + /* Align rsi (src) and just rdx/rdi (length/dst). */ > + addq %rsi, %rdx > + subq %rsi, %rdi > + andq $(VEC_SIZE * -4), %rsi > + > + /* Do first half of loop ahead of time so loop can just start by > + storing. */ > + 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) > + VPMIN %VMM(4), %VMM(6), %VMM(6) > + VPCMPEQ %VMM(6), %VZERO, %VMM(6) > + vpmovmskb %VMM(6), %r8d > + addq %rsi, %rdi > + testl %r8d, %r8d > + jnz L(loop_4x_done) > + > + /* Use r9 for end of region before handling last 4x VEC > + specially. */ > + leaq -(VEC_SIZE * 4 - CHAR_SIZE)(%rdx), %r9 > + > + .p2align 4,, 11 > +L(loop_4x_vec): > + > + VMOVU %VMM(0), (VEC_SIZE * 0 + 0)(%rdi) > + VMOVU %VMM(1), (VEC_SIZE * 1 + 0)(%rdi) > + subq $(VEC_SIZE * -4), %rsi > + VMOVU %VMM(2), (VEC_SIZE * 2 + 0)(%rdi) > + VMOVU %VMM(3), (VEC_SIZE * 3 + 0)(%rdi) > + > + subq $(VEC_SIZE * -4), %rdi > + cmpq %rsi, %r9 > + jbe L(loop_last_4x_vec) > + > + 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) > + VPMIN %VMM(4), %VMM(6), %VMM(6) > + VPCMPEQ %VMM(6), %VZERO, %VMM(6) > + > + vpmovmskb %VMM(6), %r8d > + > + testl %r8d, %r8d > + jz L(loop_4x_vec) > + > +L(loop_4x_done): > + VPCMPEQ %VMM(0), %VZERO, %VMM(6) > + vpmovmskb %VMM(6), %ecx > + /* L(ret_vec_x1) expects ecx to have position of first match so > + test with bsf. */ > + bsfl %ecx, %ecx > + jnz L(ret_vec_x1) > + VMOVU %VMM(0), (VEC_SIZE * 0 + 0)(%rdi) > + > + VPCMPEQ %VMM(1), %VZERO, %VMM(6) > + vpmovmskb %VMM(6), %ecx > + testl %ecx, %ecx > + jnz L(ret_vec_x2) > + VMOVU %VMM(1), (VEC_SIZE * 1 + 0)(%rdi) > + > + VPCMPEQ %VMM(2), %VZERO, %VMM(6) > + vpmovmskb %VMM(6), %ecx > + testl %ecx, %ecx > + jnz L(ret_vec_x3) > + VMOVU %VMM(2), (VEC_SIZE * 2 + 0)(%rdi) > + bsfl %r8d, %r8d > + VMOVU ((VEC_SIZE * 3 + 0)-(VEC_SIZE - CHAR_SIZE))(%rsi, %r8), %VMM(1) > + VMOVU %VMM(1), ((VEC_SIZE * 3 + 0)-(VEC_SIZE - CHAR_SIZE))(%rdi, %r8) > +L(return_end): > + VZEROUPPER_RETURN > + > + .p2align 4,, 4 > +L(page_cross): > + movq %rsi, %r8 > + andq $(VEC_SIZE * -1), %r8 > + > + VPCMPEQ (%r8), %VZERO, %VMM(6) > + > + vpmovmskb %VMM(6), %ecx > + shrxl %esi, %ecx, %ecx > + > + subl %esi, %r8d > + andl $(VEC_SIZE - 1), %r8d > + cmpq %r8, %rdx > + jb L(page_cross_small) > +# if USE_MOVSB_IN_PAGE_CROSS > + /* Optimizing more aggressively 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. */ > + shll $CHAR_SIZE, %ecx > + jz L(page_cross_continue) > + bsfl %ecx, %ecx > + rep movsb > + VZEROUPPER_RETURN > + > +L(page_cross_small): > + tzcntl %ecx, %ecx > + cmpq %rdx, %rcx > + cmova %edx, %ecx > +# ifdef USE_AS_WCSCPY > + addl $CHAR_SIZE, %ecx > +# else > + incl %ecx > +# endif > + rep movsb > + VZEROUPPER_RETURN > + > +# else > + testl %ecx, %ecx > + jz L(page_cross_continue) > + xorl %edx, %edx > + > + > + /* 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. */ > + bsfl %ecx, %edx > + COND_VZEROUPPER > + > + testw %cx, %cx > + jz L(page_cross_copy_16_31) > + > + testb %cl, %cl > + jz L(page_cross_copy_8_15) > + > + testb $0x7, %cl > + jz L(page_cross_copy_4_7) > + > + testl %edx, %edx > + jz L(page_cross_set_null_term) > + movzwl (%rsi), %ecx > + movw %cx, (%rdi) > +L(page_cross_set_null_term): > + movb $0, (%rdi, %rdx) > + ret > + > + > + .p2align 4,, 4 > +L(page_cross_copy_4_7): > + movl (%rsi), %ecx > + movl -3(%rsi, %rdx), %esi > + movl %ecx, (%rdi) > + movl %esi, -3(%rdi, %rdx) > + ret > + .p2align 4,, 4 > +L(page_cross_copy_8_15): > + movq (%rsi), %rcx > + movq -7(%rsi, %rdx), %rsi > + movq %rcx, (%rdi) > + movq %rsi, -7(%rdi, %rdx) > + ret > + > + > + .p2align 4,, 3 > +L(page_cross_copy_16_31): > + VMOVU (%rsi), %xmm0 > + VMOVU -15(%rsi, %rdx), %xmm1 > + VMOVU %xmm0, (%rdi) > + VMOVU %xmm1, -15(%rdi, %rdx) > + ret > + > +# endif > + > +L(zero_len): > + incq %rdx > + jnz OVERFLOW_STRCAT > + movq %rdi, %rax > + ret > + > + > +END(STRNCAT) > +#endif > diff --git a/sysdeps/x86_64/multiarch/strncpy-avx2-rtm.S b/sysdeps/x86_64/multiarch/strncpy-avx2-rtm.S > index 79e7083299..b582a4a7a1 100644 > --- a/sysdeps/x86_64/multiarch/strncpy-avx2-rtm.S > +++ b/sysdeps/x86_64/multiarch/strncpy-avx2-rtm.S > @@ -1,3 +1,3 @@ > -#define USE_AS_STRNCPY > -#define STRCPY __strncpy_avx2_rtm > -#include "strcpy-avx2-rtm.S" > +#define STRNCPY __strncpy_avx2_rtm > +#include "x86-avx2-rtm-vecs.h" > +#include "strncpy-avx2.S" > diff --git a/sysdeps/x86_64/multiarch/strncpy-avx2.S b/sysdeps/x86_64/multiarch/strncpy-avx2.S > index ce634e94fa..dfdde74751 100644 > --- a/sysdeps/x86_64/multiarch/strncpy-avx2.S > +++ b/sysdeps/x86_64/multiarch/strncpy-avx2.S > @@ -1,7 +1,738 @@ > -#ifndef STRNCPY > -# define STRNCPY __strncpy_avx2 > -#endif > +/* strncpy with AVX2 > + 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 (3) > + > +# include > + > + > +# ifndef VEC_SIZE > +# include "x86-avx2-vecs.h" > +# endif > + > +# ifndef STRNCPY > +# define STRNCPY __strncpy_avx2 > +# endif > + > + > +# ifdef USE_AS_WCSCPY > +# define VPCMPEQ vpcmpeqd > +# define VPMIN vpminud > +# define CHAR_SIZE 4 > +# else > +# define VPCMPEQ vpcmpeqb > +# define VPMIN vpminub > +# define CHAR_SIZE 1 > +# endif > + > +# include "strncpy-or-cat-overflow-def.h" > + > +# define PAGE_SIZE 4096 > + > +# define VZERO VMM(7) > +# define VZERO_128 VMM_128(7) > + > + > + .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) > + salq $2, %rdx > +# else > + decq %rdx > + /* `dec` can macrofuse with `jl`. If the flag needs to become > + `jb` replace `dec` with `sub`. */ > + jl L(zero_len) > +# endif > + > + vpxor %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) > + VPCMPEQ %VMM(0), %VZERO, %VMM(6) > + vpmovmskb %VMM(6), %ecx > + > + /* If no STPCPY just save end ahead of time. */ > +# ifndef USE_AS_STPCPY > + movq %rdi, %rax > +# elif defined USE_AS_WCSCPY > + /* Clear dependency as nearly all return code for wcpncpy uses > + `setc %al`. */ > + xorl %eax, %eax > +# endif > + > + cmpq $(VEC_SIZE - CHAR_SIZE), %rdx > + /* `jb` because length rdx is now length - CHAR_SIZE. */ > + jbe L(less_1x_vec) > + > + /* This may overset but thats fine because we still need to zero > + fill. */ > + VMOVU %VMM(0), (%rdi) > + > + testl %ecx, %ecx > + jnz L(zfill) > + > + /* Align. */ > + addq %rsi, %rdx > + subq %rsi, %rdi > + orq $(VEC_SIZE - 1), %rsi > + incq %rsi > +L(last_4x_vec): > + addq %rsi, %rdi > +L(loop_last_4x_vec): > + subq %rsi, %rdx > + > + > + VMOVA 0(%rsi), %VMM(1) > + VPCMPEQ %VMM(1), %VZERO, %VMM(6) > + vpmovmskb %VMM(6), %ecx > + > + cmpq $(VEC_SIZE * 2), %rdx > + jae L(more_2x_vec) > + > + cmpl $(VEC_SIZE), %edx > + jb L(ret_vec_x1_len) > + > + testl %ecx, %ecx > + jnz L(ret_vec_x1) > + > + VPCMPEQ VEC_SIZE(%rsi), %VZERO, %VMM(6) > + VMOVU %VMM(1), (%rdi) > + vpmovmskb %VMM(6), %ecx > + shlq $VEC_SIZE, %rcx > +L(ret_vec_x1_len): > + tzcntq %rcx, %rcx > + cmpl %ecx, %edx > + jbe L(ret_vec_x1_len_no_zfill) > + /* Fall through (expectation) is copy len < buffer len. */ > + VMOVU %VZERO, ((0)-(VEC_SIZE - CHAR_SIZE))(%rdi, %rdx) > +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 ((0)-(VEC_SIZE - CHAR_SIZE))(%rsi, %rdx), %VMM(1) > + VMOVU %VMM(1), ((0)-(VEC_SIZE - CHAR_SIZE))(%rdi, %rdx) > +# ifdef USE_AS_STPCPY > +# ifdef USE_AS_WCSCPY > + setc %al > + addq %rdx, %rdi > + leaq (%rdi, %rax, CHAR_SIZE), %rax > +# else > + movl %edx, %eax > + adcq %rdi, %rax > +# endif > +# endif > +L(return_vzeroupper): > + ZERO_UPPER_VEC_REGISTERS_RETURN > + > + .p2align 4,, 6 > +L(ret_vec_x1): > + bsfl %ecx, %ecx > + VMOVU %VZERO, ((0)-(VEC_SIZE - CHAR_SIZE))(%rdi, %rdx) > + subl %ecx, %edx > + /* Check if we need to reload/store. */ > + cmpl $VEC_SIZE, %edx > + jb L(ret_vec_x1_len_no_zfill_mov) > + /* Otherwise safe to just store directly. */ > + VMOVU %VMM(1), (%rdi) > + VMOVU %VZERO, (%rdi, %rcx) > +# ifdef USE_AS_STPCPY > + leaq (%rdi, %rcx), %rax > +# endif > + VZEROUPPER_RETURN > + > + .p2align 4,, 12 > +L(more_2x_vec): > + VMOVU %VMM(1), (%rdi) > + testl %ecx, %ecx > + /* Must fill at least 2x VEC. */ > + jnz L(zfill_vec1) > + > + VMOVA VEC_SIZE(%rsi), %VMM(2) > + VMOVU %VMM(2), VEC_SIZE(%rdi) > + VPCMPEQ %VMM(2), %VZERO, %VMM(6) > + vpmovmskb %VMM(6), %ecx > + testl %ecx, %ecx > + /* Must fill at least 1x VEC. */ > + jnz L(zfill_vec2) > + > + VMOVA (VEC_SIZE * 2)(%rsi), %VMM(3) > + VPCMPEQ %VMM(3), %VZERO, %VMM(6) > + vpmovmskb %VMM(6), %ecx > + > + /* Check if len is more 4x VEC. -CHAR_SIZE because rdx is len - > + CHAR_SIZE. */ > + cmpq $(VEC_SIZE * 4 - CHAR_SIZE), %rdx > + ja L(more_4x_vec) > + > + subl $(VEC_SIZE * 3), %edx > + jb L(ret_vec_x3_len) > + > + testl %ecx, %ecx > + jnz L(ret_vec_x3) > + > + VPCMPEQ (VEC_SIZE * 3)(%rsi), %VZERO, %VMM(6) > + VMOVU %VMM(3), (VEC_SIZE * 2)(%rdi) > + vpmovmskb %VMM(6), %ecx > + tzcntl %ecx, %ecx > + cmpl %ecx, %edx > + jbe L(ret_vec_x4_len_no_zfill) > + /* Fall through (expectation) is copy len < buffer len. */ > + VMOVU %VZERO, ((VEC_SIZE * 3)-(VEC_SIZE - CHAR_SIZE))(%rdi, %rdx) > + movl %ecx, %edx > +L(ret_vec_x4_len_no_zfill): > + VMOVU ((VEC_SIZE * 3)-(VEC_SIZE - CHAR_SIZE))(%rsi, %rdx), %VMM(1) > + VMOVU %VMM(1), ((VEC_SIZE * 3)-(VEC_SIZE - CHAR_SIZE))(%rdi, %rdx) > +# ifdef USE_AS_STPCPY > +# ifdef USE_AS_WCSCPY > + setc %al > + addq %rdx, %rdi > + leaq (VEC_SIZE * 3)(%rdi, %rax, CHAR_SIZE), %rax > +# else > + leal (VEC_SIZE * 3 + 0)(%edx), %eax > + adcq %rdi, %rax > +# endif > +# endif > + VZEROUPPER_RETURN > + > + > +L(ret_vec_x3_len): > + addl $(VEC_SIZE * 1), %edx > + tzcntl %ecx, %ecx > + cmpl %ecx, %edx > + jbe L(ret_vec_x3_len_no_zfill) > + /* Fall through (expectation) is copy len < buffer len. */ > + VMOVU %VZERO, ((VEC_SIZE * 2)-(VEC_SIZE - CHAR_SIZE))(%rdi, %rdx) > +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 * 2)-(VEC_SIZE - CHAR_SIZE))(%rsi, %rdx), %VMM(1) > + VMOVU %VMM(1), ((VEC_SIZE * 2)-(VEC_SIZE - CHAR_SIZE))(%rdi, %rdx) > +# ifdef USE_AS_STPCPY > +# ifdef USE_AS_WCSCPY > + setc %al > + addq %rdx, %rdi > + leaq (VEC_SIZE * 2)(%rdi, %rax, CHAR_SIZE), %rax > +# else > + leal (VEC_SIZE * 2 + 0)(%rdx), %eax > + adcq %rdi, %rax > +# endif > +# endif > + VZEROUPPER_RETURN > + > + > + .p2align 4,, 8 > +L(ret_vec_x3): > + bsfl %ecx, %ecx > + VMOVU %VZERO, (VEC_SIZE * 3 +(-(VEC_SIZE - CHAR_SIZE)))(%rdi, %rdx) > + subl %ecx, %edx > + jl L(ret_vec_x3_len_no_zfill_mov) > + VMOVU %VMM(3), (VEC_SIZE * 2)(%rdi) > + VMOVU %VZERO, (VEC_SIZE * 2)(%rdi, %rcx) > +# ifdef USE_AS_STPCPY > + leaq (VEC_SIZE * 2)(%rdi, %rcx), %rax > +# endif > + VZEROUPPER_RETURN > + > + .p2align 4,, 8 > +L(more_4x_vec): > + > + VMOVU %VMM(3), (VEC_SIZE * 2)(%rdi) > + testl %ecx, %ecx > + jnz L(zfill_vec3) > + > + VMOVA (VEC_SIZE * 3)(%rsi), %VMM(4) > + VMOVU %VMM(4), (VEC_SIZE * 3)(%rdi) > + VPCMPEQ %VMM(4), %VZERO, %VMM(6) > + vpmovmskb %VMM(6), %ecx > + testl %ecx, %ecx > + jnz L(zfill_vec4) > + > + movq %rdx, %rcx > + addq %rsi, %rdx > + subq %rsi, %rdi > + subq $-(VEC_SIZE * 4), %rsi > + /* Recheck length before aligning. */ > + cmpq $(VEC_SIZE * 8 - CHAR_SIZE), %rcx > + jbe L(last_4x_vec) > + > + andq $(VEC_SIZE * -4), %rsi > + > + /* Do first half of loop ahead of time so loop can just start by > + storing. */ > + 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) > + VPMIN %VMM(4), %VMM(6), %VMM(6) > + VPCMPEQ %VMM(6), %VZERO, %VMM(6) > + vpmovmskb %VMM(6), %r8d > + addq %rsi, %rdi > + testl %r8d, %r8d > + jnz L(loop_4x_done) > + > + /* Use r9 as end register. */ > + leaq -(VEC_SIZE * 4 - CHAR_SIZE)(%rdx), %r9 > + > + .p2align 4,, 11 > +L(loop_4x_vec): > > -#define USE_AS_STRNCPY > -#define STRCPY STRNCPY > -#include "strcpy-avx2.S" > + VMOVU %VMM(0), (VEC_SIZE * 0 + 0)(%rdi) > + VMOVU %VMM(1), (VEC_SIZE * 1 + 0)(%rdi) > + subq $(VEC_SIZE * -4), %rsi > + VMOVU %VMM(2), (VEC_SIZE * 2 + 0)(%rdi) > + VMOVU %VMM(3), (VEC_SIZE * 3 + 0)(%rdi) > + > + subq $(VEC_SIZE * -4), %rdi > + cmpq %rsi, %r9 > + jbe L(loop_last_4x_vec) > + > + 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) > + VPMIN %VMM(4), %VMM(6), %VMM(6) > + VPCMPEQ %VMM(6), %VZERO, %VMM(6) > + > + vpmovmskb %VMM(6), %r8d > + > + testl %r8d, %r8d > + jz L(loop_4x_vec) > + > +L(loop_4x_done): > + subq %rsi, %rdx > + VMOVU %VMM(0), (VEC_SIZE * 0 + 0)(%rdi) > + VPCMPEQ %VMM(0), %VZERO, %VMM(6) > + vpmovmskb %VMM(6), %ecx > + testl %ecx, %ecx > + jnz L(zfill_vec1) > + > + VMOVU %VMM(1), (VEC_SIZE * 1 + 0)(%rdi) > + VPCMPEQ %VMM(1), %VZERO, %VMM(6) > + vpmovmskb %VMM(6), %ecx > + testl %ecx, %ecx > + jnz L(zfill_vec2) > + > + VMOVU %VMM(2), (VEC_SIZE * 2 + 0)(%rdi) > + VPCMPEQ %VMM(2), %VZERO, %VMM(6) > + vpmovmskb %VMM(6), %ecx > + testl %ecx, %ecx > + jnz L(zfill_vec3) > + > + VMOVU %VMM(3), (VEC_SIZE * 3 + 0)(%rdi) > + movl %r8d, %ecx > + > + // Zfill more.... > + > + .p2align 4,, 4 > +L(zfill_vec4): > + addq $(VEC_SIZE * 2), %rdi > + subq $(VEC_SIZE * 2), %rdx > +L(zfill_vec2): > + shlq $VEC_SIZE, %rcx > +L(zfill): > + bsfq %rcx, %rcx > + subq %rcx, %rdx > + addq %rcx, %rdi > +# ifdef USE_AS_STPCPY > + movq %rdi, %rax > +# endif > +L(zfill_from_page_cross): > + cmpq $VEC_SIZE, %rdx > + jb L(zfill_less_vec_vzeroupper) > + > +L(zfill_more_1x_vec): > + VMOVU %VZERO, CHAR_SIZE(%rdi) > + VMOVU %VZERO, (CHAR_SIZE - VEC_SIZE)(%rdi, %rdx) > + cmpq $(VEC_SIZE * 2), %rdx > + jae L(zfill_more_2x_vec) > +L(zfill_done0): > + VZEROUPPER_RETURN > + > + .p2align 4,, 8 > +L(zfill_vec3): > + addq $(VEC_SIZE * 2), %rdi > + subq $(VEC_SIZE * 2), %rdx > + .p2align 4,, 2 > +L(zfill_vec1): > + bsfl %ecx, %ecx > + addq %rcx, %rdi > + subq %rcx, %rdx > +# ifdef USE_AS_STPCPY > + movq %rdi, %rax > +# endif > + /* zfill from vec1/vec3 must have to set at least 2x VECS. */ > + > + VMOVU %VZERO, CHAR_SIZE(%rdi) > + VMOVU %VZERO, (CHAR_SIZE - VEC_SIZE)(%rdi, %rdx) > + cmpq $(VEC_SIZE * 2), %rdx > + jb L(zfill_done0) > +L(zfill_more_2x_vec): > + VMOVU %VZERO, (CHAR_SIZE - VEC_SIZE * 2)(%rdi, %rdx) > + VMOVU %VZERO, (VEC_SIZE + CHAR_SIZE)(%rdi) > + subq $(VEC_SIZE * 4 - CHAR_SIZE), %rdx > + jbe L(zfill_done) > + > + addq %rdi, %rdx > + VMOVU %VZERO, (VEC_SIZE * 2 + CHAR_SIZE)(%rdi) > + VMOVU %VZERO, (VEC_SIZE * 3 + CHAR_SIZE)(%rdi) > + > + > + VMOVU %VZERO, (VEC_SIZE * 0 + 0)(%rdx) > + VMOVU %VZERO, (VEC_SIZE * 1 + 0)(%rdx) > + > + subq $-(VEC_SIZE * 4 + CHAR_SIZE), %rdi > + cmpq %rdi, %rdx > + jbe L(zfill_done) > + > + 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): > + VZEROUPPER_RETURN > + > + > + .p2align 4,, 8 > +L(copy_1x): > + VMOVU %VMM(0), (%rdi) > + testl %ecx, %ecx > + jz L(ret_32_32) > +L(zfill_less_vec): > + bsfl %ecx, %ecx > +L(zfill_less_vec_no_bsf): > + subq %rcx, %rdx > + addq %rcx, %rdi > +# ifdef USE_AS_STPCPY > + movq %rdi, %rax > +# endif > +L(zfill_less_vec_vzeroupper): > + COND_VZEROUPPER > + /* 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 $16, %edx > + jb L(zfill_less_16) > + VMOVU %VZERO_128, (%rdi) > + VMOVU %VZERO_128, -(16 - CHAR_SIZE)(%rdi, %rdx) > + ret > +# ifdef USE_AS_STPCPY > +L(ret_32_32): > + leaq CHAR_SIZE(%rdi, %rdx), %rax > + VZEROUPPER_RETURN > +# endif > + > + .p2align 4,, 4 > +L(copy_16_31): > + /* Overfill to avoid branches. */ > + vmovdqu -(16 - CHAR_SIZE)(%rsi, %rdx), %xmm1 > + vmovdqu %xmm0, (%rdi) > + vmovdqu %xmm1, -(16 - CHAR_SIZE)(%rdi, %rdx) > + cmpl %ecx, %edx > + ja L(zfill_less_vec_no_bsf) > +# ifndef USE_AS_STPCPY > +L(ret_32_32): > +# else > +# ifdef USE_AS_WCSCPY > + setc %al > + addq %rdx, %rdi > + leaq (%rdi, %rax, CHAR_SIZE), %rax > +# else > + movl %edx, %eax > + adcq %rdi, %rax > +# endif > +# endif > + VZEROUPPER_RETURN > + > + .p2align 4,, 4 > +L(copy_8_15): > + /* Overfill to avoid branches. */ > + movq -(8 - CHAR_SIZE)(%rsi, %rdx), %rsi > + vmovq %xmm0, (%rdi) > + movq %rsi, -(8 - CHAR_SIZE)(%rdi, %rdx) > + cmpl %ecx, %edx > + jbe L(ret_8_15) > + subq %rcx, %rdx > + addq %rcx, %rdi > +# ifdef USE_AS_STPCPY > + movq %rdi, %rax > +# endif > + .p2align 4,, 8 > +L(zfill_less_16): > + xorl %ecx, %ecx > + cmpl $8, %edx > + jb L(zfill_less_8) > + movq %rcx, (%rdi) > + movq %rcx, -(8 - CHAR_SIZE)(%rdi, %rdx) > +# ifndef USE_AS_STPCPY > +L(ret_8_15): > +# endif > + ret > + > + > + .p2align 4,, 8 > +L(less_1x_vec): > + /* Reuse flag from `cmp $VEC_SIZE, %rdx`. The idea is many > + buffer sizes are aligned conventially. */ > + je L(copy_1x) > + > + tzcntl %ecx, %ecx > + cmpl $16, %edx > + jae L(copy_16_31) > + > + COND_VZEROUPPER > + cmpl $8, %edx > + jae L(copy_8_15) > +# ifdef USE_AS_WCSCPY > + testl %ecx, %ecx > + jz L(zfill_less_8_set_ret) > + > + movl (%rsi, %rdx), %esi > + vmovd %xmm0, (%rdi) > + movl %esi, (%rdi, %rdx) > + > +# ifdef USE_AS_STPCPY > + cmpl %ecx, %edx > +L(ret_8_15): > + setc %al > + addq %rdx, %rdi > + leaq (%rdi, %rax, 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) > + ret > + > +# else > + cmpl $3, %edx > + jb L(copy_0_3) > + /* Overfill to avoid branches. */ > + movl -3(%rsi, %rdx), %esi > + vmovd %xmm0, (%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 %xmm0, %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 %xmm0, (%rdi) > +# else > + movb %r8b, (%rdi, %rdx) > +# endif > + ret > +# endif > + > + .p2align 4,, 2 > +L(zero_len): > + movq %rdi, %rax > + ret > +# 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 > + .p2align 6,, 8 > +L(page_cross): > + movq %rsi, %rax > + andq $(VEC_SIZE * -1), %rax > + > + VPCMPEQ (%rax), %VZERO, %VMM(6) > + > + vpmovmskb %VMM(6), %ecx > + shrxl %esi, %ecx, %ecx > + > + subl %esi, %eax > + andl $(VEC_SIZE - 1), %eax > + cmpq %rax, %rdx > + jb L(page_cross_small) > + /* Optimizing more aggressively for space as this is very cold > + code. This saves 2x cache lines. */ > + > + /* If rcx is non-zero then continue. */ > + shl $CHAR_SIZE, %ecx > + jz L(page_cross_continue) > + bsf %ecx, %ecx > + > + subq %rcx, %rdx > +# ifdef USE_AS_STPCPY > + leaq -CHAR_SIZE(%rdi, %rcx), %rax > +# else > + movq %rdi, %rax > +# endif > + > + rep movsb > +# ifdef USE_AS_WCSCPY > + movl $0, (%rdi) > +# else > + movb $0, (%rdi) > +# endif > + jmp L(zfill_from_page_cross) > + > +L(page_cross_small): > + tzcntl %ecx, %ecx > + xorl %eax, %eax > + cmpl %ecx, %edx > + jbe L(page_cross_copy_only) > + > + /* Do a zfill of the tail before copying. */ > + movq %rdi, %r9 > + movl %ecx, %r8d > + > + subl %ecx, %edx > + leaq CHAR_SIZE(%rdi, %rcx), %rdi > + movl %edx, %ecx > + rep stosb > + movq %r9, %rdi > + movl %r8d, %edx > +L(page_cross_copy_only): > + leal CHAR_SIZE(%rdx), %ecx > +# ifdef USE_AS_STPCPY > +# ifdef USE_AS_WCSCPY > + setc %al > + addq %rdx, %rdi > + leaq (%rdi, %rax, CHAR_SIZE), %rax > +# else > + movl %edx, %eax > + adcq %rdi, %rax > +# endif > +# else > + movq %rdi, %rax > +# endif > + rep movsb > + 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. > + */ > +# ifdef USE_AS_WCSCPY > + rep stosl > +# else > + rep stosb > +# endif > + movq %r8, %rdi > + jmp OVERFLOW_STRCPY > + > + > + > +END(STRNCPY) > +#endif > diff --git a/sysdeps/x86_64/multiarch/x86-avx-vecs.h b/sysdeps/x86_64/multiarch/x86-avx-vecs.h > index dca1089060..01bead1435 100644 > --- a/sysdeps/x86_64/multiarch/x86-avx-vecs.h > +++ b/sysdeps/x86_64/multiarch/x86-avx-vecs.h > @@ -27,7 +27,10 @@ > #define VEC_SIZE 32 > #include "x86-vec-macros.h" > > -#define USE_WITH_AVX 1 > +#ifndef USE_WITH_AVX2 > +# define USE_WITH_AVX 1 > +#endif > + > #define SECTION(p) p##.avx > > /* 4-byte mov instructions with AVX2. */ > diff --git a/sysdeps/x86_64/multiarch/x86-avx2-rtm-vecs.h b/sysdeps/x86_64/multiarch/x86-avx2-rtm-vecs.h > new file mode 100644 > index 0000000000..a5966701ec > --- /dev/null > +++ b/sysdeps/x86_64/multiarch/x86-avx2-rtm-vecs.h > @@ -0,0 +1,26 @@ > +/* Common config for AVX2-RTM VECs > + All versions must be listed in ifunc-impl-list.c. > + 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 > + . */ > + > +#ifndef _X86_AVX2_RTM_VECS_H > +#define _X86_AVX2_RTM_VECS_H 1 > + > +#define USE_WITH_AVX2 1 > +#include "x86-avx-rtm-vecs.h" > + > +#endif > diff --git a/sysdeps/x86_64/multiarch/x86-avx2-vecs.h b/sysdeps/x86_64/multiarch/x86-avx2-vecs.h > new file mode 100644 > index 0000000000..16d7ae5147 > --- /dev/null > +++ b/sysdeps/x86_64/multiarch/x86-avx2-vecs.h > @@ -0,0 +1,27 @@ > +/* Common config for AVX2 VECs > + All versions must be listed in ifunc-impl-list.c. > + 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 > + . */ > + > +#ifndef _X86_AVX2_VECS_H > +#define _X86_AVX2_VECS_H 1 > + > +#define USE_WITH_AVX2 1 > + > +#include "x86-avx-vecs.h" > + > +#endif > -- > 2.34.1 > --000000000000b0293905ec8d1d24 Content-Type: application/gzip; name="strcpy-avx2-results.tar.gz" Content-Disposition: attachment; filename="strcpy-avx2-results.tar.gz" Content-Transfer-Encoding: base64 Content-ID: X-Attachment-Id: f_la0u0iti0 H4sIAAAAAAAAA+z9a7JlPW4ditZvtWI1IL3N98MNcAPcAUeFrLAdIZcUqpIt9/5OAoNzkcSYK1fd E7Kvz3X+yP3llwmSE3yBGMDAn//yj3/7j//z3/zxv/9L+PnLv/zlD/8av9z1q5Q0fvqa3frTuZBz 8e4PPsXoSo4u1T84H1KNf3i5f5XRHL/++c9/+eM/vV5/+NM//PG/fPp3v/v7/0N//c1/+Ls///Pf /+XPr3//D//0715/ltXwN3/8+//6n//kf8mP8Pr193/3p9fr13/747/8x7/9L5eufv3p7/7H6/r1 6x/+/j/Jz+vP/3b899+4l/xZf+DnLx8q/px+Yu3ys6Qw/v6np3j9xSnnD7n8E32Rnz7L3/y4GJic O+XqaP5X/ampS381dioX0ioX0k8tSX7mkKU/GZKR86Y/X6W/5jL6o+MMRq50jFP1UlOmcm2Taz99 DOz66VoRvXgZqJGLVi8e/VX0R78v2e9rKhc+ymUzf/Kz/LQx30Ou0u8rp1yDPnuAXmIicuFl+hsq vn66HHW9ZKaXkMsm58NPLlV+RtdELjC5aPqrLmp/Jes8hMLkzLy3oYdLL64W3Q+lErlk+mtjfVx6 KbWpXgobZ7Zy0k/9yRn7obL+smhv0cs1AW7o5Rqo7JQfP9aBkStWL6Xt/RW238uxzq79E6PoRfft 1R/9vmr6y7IfLjmv+mye7fdmxzkOitFvfX1YZ93Ilabrs5ZK9rt/LT/39Zmz/Ay56vrcxukf+5P9 NvrLkey/MPuz52CY+92/7Dk45cg+ql7HOY46OXfXeYizP3sOugS9NKLPKUf2URx6ST+9Yd7z+n3p /j63ybVrH4ge/U/tWfsrVC6dcnoC+GtDFZXzVO48d6uX8V0L7BroWGeOyh37aMhFjDMHnT8uV045 Oa+v/vql69Hfi+rF3iuYh+zm/uNypz6r6mV8X9XvS1TO6DNhnCUl3X+Byu369OOAvvTff0LS/eA7 nb+467Nf56WMM14bSOevcLlyysl5fZ3zqYo+a6ffl9wp1wPmoYteuutULnG5615pUfVZqVw75QLW tXNR+6P6zMd57S59JJUL8cM486mXFmd/Sdd1p+vF3NN6Pzc9H2Qf0e8ruz6veRsfOL5T7B7/k/g+ KumUGwfn+Bmd7KMxHUyunXJ+fNf4GfV+5/3VYPpzRfSSYGdlOg+1GLlatD8Z79UfnYdm9DI+efQX 08vef285oxc/1teQi5Cj67oZvYRSZH2Og3qMM9Hv64dergt3nA9jP8Qo8xfo/utWL+Pc9EntirHO 2PcFc4/JOh72YMN5tt1/bzmjz+Sy/MyXwTTWS2PrJTijzzjO6XFej3Pi0mdk+gzO6rMH7ddjfdLv O+2sq7+q66ypPsVyJ3JGnzGF9/035Gh/gawz7W8c3B/kDr2knxQz9sPo99qObF2H85y/9B91Hmr2 Og9Un9Hqpc/5wD5i6zNEo5fcdF27aZfTeTfvnFbUHux+vnOoXpJdZy0t58XxfnjLmXWmcv7aR/nD vCerT8x7x7wHOg/n/ZCu/edFL76pPV+pPs/30fXg6E3kvb4DQo5M7jzny7VOkpwXBfOXqV7Oc778 lFCkv9q7fh/vr51yNeg4Yw3P52A4z/mrv+JFruD8jFSf5zlfLgML/UUdJ/++9jrXWdL3WHVYZ7lR OaPPMu516a9qf3Sc5/1wzUNVudDT8z0WzvthbAg9ryvuzUr30Xk/pJ8WVL6q3dO5Ps/74ZLLXeRS yvouZuOM5zl/3Sep6s+Wnu2CeJ7zV3+y78aDTPuj+yGe53z60XfK+Nm1P/Z98Tznkzz8ZZwZ90Om cuWcB4+fEfdKY/ft6Weo1/rX92Zv+o7zna2zeN4P7VqgCfrMut+53KHP68Hho+7DKPeKS3Qezvvh khvzfcnFonJ8Hs774ZJrqpcC/0Sg+jzvB30Yyb5wavcUOs7znB9yQfrLBecSO1/iec4PR4ieg9Xr ueR5f0YvXu6xLAfEGCe1J+J5zg/HoK7reS5Vuj7tOe99l5+x5A/r7HgHXGLi12iyjcSu4/o874d6 3ZdB5qHpueQ8XWfn/VCvi0TnL8h6u/5I18t5P1xyTb9vuDifz4nzfrjkhv149efVnnCZyxl9uqTf F1r4sB/Oc77CrhvntsrR+zYe53y47ECn60Xtn8t84nK7XoL7CbJf2zXvuj6pnRWPc/6S83LfXnJJ /eVcn8c5P/rrYbl3r2lk8279n0m++Dom5Dx0cj0RueP9MM7BJuuzwx/J/SjpuFfG9/Ui36f35/V9 TJ/puFeGnGh4rOum5y47J5Kz8xD0/OwvnNdMn+m8V7oACbKfos4fXWfpvFfade6qfzfgvUnff+m8 H+qP4g79WmB6/1F7N9n7oQz7/5IDLtMdO1+SvR8GICA/gcvw+bP3Q/MZ+tH3H333J3s/NKfzHgLs AqrP4/1Q1d78pWKyzirtz94ret+2W5+Vft95r4yOVC7E/GyHpONeCeHaCEXXi/iLrmuCrs/jXrnO lzTO3bG+1f501O+WjntlyI3z4ZLTc/SSo/v9uB/COMD0+wreAYmO87gfgh580l8on/prVk7PwSr7 XtxFRK4avUQ53xvW6Y+nfuhUzTnYxzhHf7AnPJ2/4/0wrq/xTuni7lM/Jt23zeizBD0nuu73wPff ea+4a9/qvPfkn/0oyd4rKek8DAft47s/2XtF5+E6J8ROe3g3JnuvjKtm/BwPedlHbP6yPeeT+Af7 TwH+l9g5n+05P7aWyME+o36pbM/5OOXU/+LoejnxuDDeRXou9SL9RXpeZ/sOENxoXNOKHzVqv2Rr 13U9z/REHnJs/oq5b9VjcckBZ270/XDif9cxHdX/UoA7BWq3lmM/XMdDgX9+ABjiZ2fvgBqsXFK5 lORd1aj/pRYjp/75S0793o36X5qz/WXI6fpsgemlJSPXga+kqDhQZOuzWb20+X1OcZnI9NKNXuR9 onKKkzSml37opf/oi/7qV+2f67hf9ZLx70hcggc+feNVnshZXHvivh5+4dbW/srsz/j5hpks/c24 hG0/TDmLayfBe9f+1nl4v9dPueE+k/5CJf3d+8b2F/X7AuJDmtoFChR/ipsZdoDYy/p94xlP5I74 l3gpdJyfMYrDXc5d2t9hn/Uf9aS2HyDsT3I2zgPnkqvAjwIbp8Wn9QaeOPztJzrlzvdtuu7ncd9e 9o/a87B3DzkSryH27nh36DnYI5Oz75VeNV6jh7nOEpEz57zH++06sIEHqP15yNn4iR5m3AXeqakT ORsH0Zq+392ML1A84JBjcRCIX4oT71/n7zkOQi2va50izsOFwOQs3ug1nkHwUPHPt0UuPMppXNYy D3p+Qu4+J879MPzPVfZDVj877mnI3evKxiVk4P1J8XDB1YlcOuX0nPfyMJJxvqicjUuoKldC0/6o nI1LiDMOIqpcbFTOxiU09KfvlZoqkzPxBcVBL7F90ouNL9AdqUCj2UdvuePdeP3Dgf/1H+yw6R88 5Wx8gcTNCF5ZP3yfjS9IiEsIpXyYBxtfIOffwGWc4u8hUrlk+gM+FhDP8NCfiS+oCesMcSzbefa+ x0691Ib4CbFsnDyvmZyJL1D7bOBcap8FOu/Hvr3uPbEHmsZhvuMHjZzB47r4Wd114aofLNDvI/EF 4g++7gff7Ln0lrO4r9P4wT79mPT7SHyB+M3C9X5XuUbnncQXiH9w3GN6Twc67yS+YK4zxEc2T+UO vYRrApvKvVSu0HGS+IKueqkNeAAdp40vSFVxZvFDe3FLMjmLhxfEhyTgxez7bHxB64gvKLBDEpcz +kyil+tnLYv/xciZdRaDxzyqf8Kx9cLiC5ri6AX4UWXzQOIL9B0d1U801ieXM/r0wO2HQ/H5+2x8 QUiqF5d13uk5weILqq63rOvF0/OMxRfkqHrN6UN/Nr4gIV7jlqP9kfgC8ReE6/5T/3xh9yaLL3jp OvNbHIuRM/ocDxXRK/AOeo+R+IIc9JyowN8L78/oM2bEBXmdv0z3g40vkLisIRfUDx3YPc3iC+rE b9XebXScNr6gyDobgap6LnWqFxtfMHGSgHOi0/1n4wvEDzbw8IbvY3YBiy8Iiv9pnM/DuUviC4r4 8xPO3+kfPOVIfAHscrGb7vgCI2f0maN+X3Poj36fjS/ImP8W4Mek54uNL+jAb8eFIuuT6sXGF2hc +ghsT0t8gZGz77+q+G3FuzGxcbL4gop1pvZgp+uTxRcknfcW9Lym9jWJL6hFvy92xS0y+z4SX1Ca 9ic4rlO7ksjZ+IIAvSBulN63JL5AfpbrHa/2NX8fkfgCPd+z+oeHH5rOg8WPkthX175Q/7xLVJ8W PyrAUxvOs0T1SeILMvSi4/T0XmHxBV7xaV2nT3qxOFDBPMw4eEfHaeMLAvD+7vR+b2zfkviCiPnv GifgGv0+Fl+g85fhnyjsnCfxBU7e0Zd+sK75+jR+aInPkHcZ7k1P16eNL3DAO3LT/VeoPm18gY86 f7GpXhKdPxtfoPHFVR5U0h/9PhtfoDjzdY7iHOTnBIsvmHEsuh/oOUjiC0LUeIYcEPdL95+NLygV /Wl8T6T3EYkv8FlxvIY4iELXJ4kvaIqPtaLjlL+ycja+IM19ofcYXWckTqDhnQo/X0lsnZE4AcVR O+xlSWtgcgY/Cg77Af6JzObhjBMYeDbWWZ52Fu3Pxgk0uR/q9Gd56l8icQKl6frsOu/esf3O4gQ8 cDzNs+n0XUziBHSddHnwC27P+zP7r0p8QLveZdoftXdJnEANim869Us1+g5ncQIF+slqF2S2rkmc gPiFZZ35D+uMxAl43UcS1+4EBmRyNk7AzX2k4yzsnCdxAk3s4ybA+zve+5SzcQLi/xw459wPXM7E CUhc0CWXEZdHz0ESJyA4jsSj6D5y9Pue4wQ07lTCBZiciRNIQfHimRdC/QwkTsA5lYu6b/k9TeME VC7jPqp0vZg4geCwzqLGhxRqh5A4gSrjbBL4Ke8xOn82TkDi2YMGDsr9zvuzcQLjfghe49Kd5ndZ OXs/ZOD2DXhjpOeEvR/SGN+YR8QJUH8yixMY+1Xi3nQe6PvojBMY48uK97cIfw9bLyxOoKtc17g8 7o8kcQIxVL2PqvrPAu3P2vMznzLM9cLm3cYJxD5xbcWnK7VbSZzAzG+sKlcqmwcbJ5DEX94kPEjv P3ZOnHECY7t2/T7x+ww/NOvPxgm0iT+0oN9H7UESJ5CArzjE6dB7hcUJACdpGpdQqX+exAmI/9Lr Bf3G7U85EycgcY0yzvYBd2JxAmnKpedxkjiBqrhv1xt1nvMK4H3idfAaH6L5wnc+8yF34sVJjr/x s3fEsaj9CTk/+3vmIaiTh+C1yL3zrvdzooq7RtY18hGq2j1GLp1yDfm3xWs+s9rlRq4ZOeQllwC5 wOSOc2LgoXnKxWVdG7ly9tfRH/LqgI+dcuHUC/I9nfq1nuVOvSjuO/qDXjL9PhOXkMWffB2DPZN1 dssZ/C8pvhl+xv96ngeD/02L5tpQqpdGx2nwv1xuPE710uk4Df6XOs5rxOVV9X8auVMvKQMHcurX r43KGfwvIXLnMkB0vagf08ideslxxw2Rd33KEbw/vLb4kEjn4Xz3X/bneHdc50zQ8yUkqs/z3X+9 b8XuGY4exOtTvZzvfg+/lBp0ss7ouj7f/dc4kffpEAeRqF7Od/+QU3zM1fphnOe7f4xT84QdcATe 3+nf9cjfHHYo/G6dyhm9VOQzO/iXCj1fTv/utU6GX6nLs1Pnj+6j07871rPXeZzxGi8iR+KJhv03 +C7Ez3T76045ghu+dH3OfNHI5sHghuFnHKliZ7kVDzByBod1gkt7SeySdwAfZzNyTuXueFqmT4Mb Bgk0Vjn4bej3nf6CIBtW5BAXm9k6M7hhQHy4hz9z+nuMnN23kjfh7vcRPT8NbujVDznsLIf4ZKqX 018w5Kp+X1jxRiNn9q3Eo3gNuJd1xs4zhhtqHK6b+aKRjvP0F1zjTLr/gkdeMtu3Bjd86yXA78b3 0elPXuRwvkQ676c/2SPuejjqVj+mkTPrDCfAT8X56ak+z/th+jWiOM7knUr7s/Ehuo+CEDC9/QVG zuCpwuMhPAs6zkD3+3k/BAlYk/6KnvOBzsN5PwTlbxlyyMvy9Pssbpg1Tq61GQdB9XneK9c4cb9P XMbT/WfjShSvGOPsH77vvFcC8uPiT9Zxdk/Xmb1X7viJon6+TvVi75VQtL+AOI/A+jO4YVC8cMhp XF6n+8/ghkH//VifXf0hgdkTBje85LrGCXjlC+rU3jW44RinrtOZF0nvMYMbXnJZ9eLhb41sXRPc EDxYLeh9GwId53k/jPgQjROY56dn68XghoO3QnH0QcAl/hf6fef9kO74kILzjN5/Bje85BDfkzFO avcY3HDIoT/c75n2d57zl1zW+cuwPwvbtwY3TNf4sI8q7ls6f+c5f/XXdH0iDxrxL6fcec5HeYAP eaf+nk7vaYMbRnEIKn8BcG26H4xfSv1LTdw26u+h64XEDyLOI0TYBVQv9n7o4LeZeYONzoO9H7qv OM8+2K0GN4xCMCNyDvctXWc2frAjbjSr/4zbIQY3jELYo/Ou4+TnIIkPabr/cgHfDD0Hz3P+HVcy 8+bpvXnihtJfQn/pQ3/nOX/J4XzBPHj67rC4oVqIXWhD1T/B+jtxQ4m38dgP4GNh++HEDYdcUj4P p+8HT9enwQ0HX4nuI4d4hsrOF4MbFvAlJL1XhtyLypm4En33ZcWb77zBU+485zP4JrMkzLxxLiNn zjPhZxNeD32veKoXe873ruuzz7hRth8Mbjh4PJTPo6Y1ztHIWb2U1+vNP/IkZ3FDOee7TOOzH8zg hkt/iJPzdB7s/dAD+LrA5/Gi807iSgriZhDHyeVsXIlquFwPON3v1H45cUPhS4i6XjzidKgc4Z/o uj7zjK+j68XGh6g9MfrT/UfPwRM3HOME34zaMT+e3kcnbjjGWVVO+UfU707kjF5S1Li1hLhK+l4h +cXynhrpsHhvUj/tiRsKX4WXn8oL8fDOOXFDOXcjzhnYZ/T77P0w56HFFS8+5ez9EDHvM16K2q0n big8HrrOZhxLYPv2xA0lPkfjpRp4JOh9a3DDa5wZ/fUP7/cTNxz9JY3vER7Ip3eq4ftt13pWuarv W0/nweKGoej9V2Y+OrVbSX5x1fOstMlry+bB4obqCb/OwT7fqay/EzccdAlVfqY7b5Dp0+YXax60 18Tpx++zuGFwwC3GA1Xk2PdZ3NDre9qpXXjn9RxyFjdMAfif0/jPWtj8WdwQcU/6gHvn1Z1yRi/w /GlC8jvO+JCzuGFQHEEDTR/1cuKGwy+heeUZ+bd9O+dnXrJ9bwpv2a+i/j3jJ3rMtx95Exr/khW3 D9u7auYlG7/UdU6AH6yCp217b77zDU1+nOZlheuBrPjRNs63nM0bDDrvVfO56oY/vOUe8wZza9ae uOVI3iDiSjpww0jHafMG/Rzn3O9U7omX2CvPwrle3nJGLwn7Afn9+759y9m8wSLnS+3w121+olvO 5g1qfmMUwnWZv0TlTN6grtio/olHvRBe4omraVxX2/wobzmTN1jRX+jeni9vOZM36BE/Af66Fqmc wQ2VJ1jk+ic5kzc4572DjzrQ9WlxQ8H9xjkD+8XT+bPvfuHzE5xZ9m0MdJ2RvMEw31Xqn0hczrz7 FdeOkmjxzq865Rgvsfp3vfL3uE71yfIG9f3u4Gfw9JwgeYNBeUOVz+ypP8tLHFKEXPmwj0jeYNU8 IvgLwLd2ypG8wab4CvKWIl8vJG/Qaz6Q033bGtt/BP9r4IuVFXjGo7zlbN5g1Hy8NHkgudxz3iDz Y77lSN6g8lGnuvL6nXIkbxD+Qd/1XezZ+UJ5icG3Pe9bNn+Ml7jq93nNK9jf4W85kjeouIz4C0Yc Nf0+mzeYuu5bj3haus5Y3mBG3ifiShzb7yRvsHjkwwL3rWx9WvyvO+V16L18WmeElzgAf0D+rafj JLzEXfdtm3gxnQebN6j+8qD359O+ZbzEYocExWXuvDojZ963us+nH0bCR4mczRtUP0EGz9sRP/GW s3mDkEPcvat0nISX2G1+Ik/tJZI3qPx8+SfCr1/pOAkvcVb/p+afzbylU47kDaK+jPzNzcNj5Kw+ m/r1++zvReXsu99hnBl+G96fzRvM4IdGvkyjcoSXuGoew3CNSl4BnT+SNxjB39pXPuNDjuQNKl9h /kF9hN2P+ZazeYNB7yPMw47jveVs3iD4YiPy/wqbd5I32HH/TXyzsvOT5Q3C/1I0j+GhP/Me07jR Arz59Nu85UzeoMbn3P4ln7mc8dcpzlWF2NT4bd5yNm+wgc8YfBC8P8ZLjPUCPk56b9K8QfWfzTgr aiczXmKcEw287tQuYLzEXee9A0dwdN6tf1fP66z+EC+0ukSO5A12+DHhF6bni8H/CvKENYBU7Gs6 TutfSojDRXxrqezcZXmDYn9UjfN53LfWLxzCzMfDeqHzZ+8H5Q0Z6y0veYOnHOElLpoPq3jsNWw6 7yRvcObxIe+F7z+bN5hm3mAGLzG7b0neYIvKM1s0ryfS+4jlDcoXd+W3OeMVbzmbFxKQJzXzbwtd nyRvUOzrCl7Vyxxl/ZG8QT/zuTQeulD/C80b1DwNh7zkwtYnyxv0DfOB/NsXlbP6rJDD99HzjOUN ep3/qnw6/Dxj/MI4Pxv4TR2zd1neIHhDo/IPtsrmj+UNds0/8uC5pOcSyxusmh8XNb8D/LunHMkb jODDBX8ktUNY3qDXPMVBJCnvDnaeEfxP/NaSZyP+5MK/z94PtaE/5SPrdN/SvEHk7YK/oNB1zfIG kQeteVmh0vVi8wYj9AnebEf9LyxvMOn6zpCLVI7wCydd3xF2K31vsrxB5LlNXhV6TzN+4az7Pc37 lo7T5g2mKRchR+fvzBtUwFbzFNVO5vvI4n+6YjXwZawzeo8xfuGk6wx1tnyn+rR5gxLPEG4/dKd+ aJY3GBP0+uH9zviFG/LxJs8X1QvhFxYeZK/v6tEf0wvLGyyaN+hwj1F/JOMXHvfDkPMkPvItZ/MG 5X3UEQ/x4LcheYNa/+G6j9S+jrw/a8832FlN4ypLYfNn8b8bH5N82kuO+hVP/K8obid+eo2r5Ovz OW+w69/MvORTzuBcRd8dXt+BZ/z1lGP8wrALGvKW6Luf5Q1CTuL9z/ycKcfyBgv6A65Gz0GSN5hm Hh/yuRrTJ+EXnt/nwDtJ/Yokb1BvYA3w/3XXCT3lDr10gdU0nwv5vupn0MKiH+szI645w3+mOMkh x+qSDjsizXqTQmPxlgv4d8YvlX+wI6Ugxrj/NH4iLv2Q9dn0PXSNM826ZWovQW7ilBY31DwUib/X 9VkqlTvxsW/lTtywzXmvFbhaZHIGN+xqQY18tbbgzEaunHIN+6+Cj7NQvRjcsGfgfzWiTigdp8EN 6+SrnP0lLmdwQ3k/DL5LxFlFqs/TjnSK9wruoXpRP4qRK6a/qP7WCN7zQPV52oMOfJPhJ3jgeFwu GTnwY3q9b+UkIXJWLzpy5YFx4pYkcraeqY+oV6d5GuAvN3K7XrrQz+n3KZ9qVX63U+44XzLyYUc+ V9Bzgn+fxQ0n/uCBP6gf08gZP3uuqs+K+53vP4sbZvjLE/LqOu3P4oYFON5893e6ri1umDPqoyMv q9N5sLih3mMB/BzXsUj3rcUNM/JsEngWGtWLxQ1LV30i7hc45Sl3+oUnX6WHX/lHTjwiZ/QSgFe1 abeydUZwQ9Rj72HGLzG9MNwwzDqaefHTGjmLwyKPoXnw4vD+jD6ji+95dFp/1cqReqbgYc1trfth 5Ig+Ua911u+g/dm8wYw6rwk8PIHLWZwLdTvFz+C1ngqRe8ANo/opnPK8WzmLG+YQl/Ni4ptGzu4/ D/5PjVOFPX/K2bzBBNxQLLCb39vIWb5R3Edx8hnT9WJxw4JxprLijUbO6vPGU1XOUTmCG4Y5fzg/ 6bxbf7LWVRv5L/pOjXQeCN9oBC6DumzUfqG4ofq9Z55b4XLGL6x1U/OdZ6p2+SlH+EYT6sClNa/H yBm9FOBcCXk9fF1b3BB2q/Je3PGYRs7qM6DeJ+JiH/o79JlRtzprvOrj+XLeDwk8Skn9YHf+yilH +EZR1/KuW8blDG4ofOcjDlfjnnpk88f4RgvihVHnfHs/vOUsbog4+IY4D2ovsXqmfvJOQo7td4ob anx5rYh7ov1Z3DDMOHEHObYfnvlGNR5Cn51MjuBjmi8j747br2/kLD7mUSetfbgfGG7otZ4p6vGB V/OUs/7kElXOtxVXM3IWN5z1KdMnOYIbRo9x+ufzheGG8OsHnBONnS8GNyzgOSyoy6757FbuPOdH gpWu64C8pUj7s/Ehisc1zUe/ccNTzvqlJm6YtU59oXYkq2ca50+9p19c7hE3rJPni65rm08SQkV/ /kN/FjeMXvHNuNUNNHJGn8onVhW3uvM3TzlSz9TrvHfY84GeL9YvPHlR1U7TuopEzuJcUf27AfuI vjcZbhhUL1XjFT19/xHcUN7DA1dD3fHM+rO4YZz8S1HfxZW+O1hd0qzjbIiDoPcKwQ0V56hSAETk 2DywuqSz/mYrH/qz+SQ9AwfCui5s3xLcMKIedA1rXdlTzsaHhK51JlFHsz3IJdtfxXhXXk0j14wc +By9B65G5c5zvgnRjOBq4EGm736DG85x9snT1rk+j3eAHkdYZ4rn0P1ucMOm8eGjP9gh1H9GcMMK uVhXPNXIGXwsYb0UrccQPNvvjG/UT/5I8DJyOYOPaZxGv/mvqV3A+EabzsOMH6T3O8ENE/hw9QQR Gi0mZ/Si+dZdgPDn/ixumIFTurzyBRk5c54J3jTjBZykxxI5ixtO3jvY5YX6ewxu6MCXfq1v5BcH uq4J3+iYP5l/2Ml0Xdv7QfLlpe71Wg/llLP3g/AKDznErdH3LcMNG84l1KOl737KN6rzF+E/o/cD ww3BaxvLWl/GyBG9BNyD4HFh+4HlSXWdP8R1Beq/Jrih4g9DPxqfRdcZww2BTwMvLtT+ZHyjN26o eCN9b1pcpoj/sv20GY9J9y3BDSvyZZpHnhTrj/CNTj5Or3FrYpZbOYsbzrws1Oup9PsIbhiBr8A/ X+k5SHDDyRcL/pda2T3GcMPX7E9xUXoukbxBD9xQ+Kxv3PCUM3ppE592QfOI2trfB7xY4kOawDpq D8r3aUcLT6nhudQ8sLseLebdyKVTTvlUncZ73ziXkWunXAKODv8u9HLKWf7PiaNLHOid/2fkyilX X5DTdz/wv1PumL8sblbBNxP8RJ72Z3hDg39Nveh+7/T7LI5XtX5cjsDj1C9s5M48N4985oB6kb3T 7zP5f6EC7xgOsDfObOROvCok4GMFOCyXM/l/00NyPRzCh3k3+X/RY5xZ4zWQd23kTr0ob6+M87XE F5xyh33WZJmonK7rovvdyB32bhDCpVHnHHVCY6TzYHE8P3G812vxexs5gyNE5Z3UesRe3BtMLp1y GrftgY/OuklGrpn+HHgE++qnPeUsL1ws2p+b9hLVi+WFk3qkUv8PcU/0XLL8bjFovTMPf4+n/Z1+ WnUIap4w6j/QebD8blI/YJRVxzx0Kmf53fQ97CTwbMhlLmf0on6XAPxp1ik85BiO98J5OPmo2bom /J/CI+5n3QIpv8TkzDpryB/z4JvJvD+jz+p1ncW21vU65SwvnMZte/BlTP4QI3fo08Mv7Ge8okv0 +2z+X5X8nGFfa93OxNaZwfGCBHrIfYt5f9H5O9/vQfMJRl55WnH7U+58vwfUORv1cJAPy84Jg+MF zWO+eYZnPbdT7rBDFG7a8WI6zvP9HqSws8wD8kL4Ojvf70EeUsoLsMZ7Gzmjz4BzcPLlZTpOywun eUvjPkKeMF2fpJ53Qb6o8pF5er8bHC/9KA/EwMXX/Dgjl065Drw4TNyQ6vM857PeY5K3C14j+n3n OZ+QBxQ1v99rPguRs3rpOk6tDyXHBZEzOF5E/l+e9QqofWZwvKi8DOP75M8zD8XIpVNO6+qNfGGc E1QvNs6jgd/NTfvsxeRsnIfWUUwSmCW4IdWnjfPoiLvoaa3zesgZHO/N66e8AhPXNnJGLw18jvDv OsfmgeB4zifIw69B+yPxGuBFbeAvKOycZzhehl6C3kedypl3QJd3QFb/kKwXqs/zfijIg03qh7lx eyOXTjnlOUngIZx19YycwasC8loz8ACNhz7lzvuhiANEcVX4r9k6MzhegT7T5OPk55LB8YrG8d38 qE/jJPxuMUGfyAOj6+w850fen8qVsvKXn3LnOZ9Rxyb9aDzn9H8aObPOOvIGZ73kROePxPNpHVSx PyTukH6fjfPQOk1ZiMjecXlGLplxVuTRwj9Iz2uD42UpMKJ1bBWvynT+zvsha72IMU7EzVB/gcHx kgQ2S3+z3icdJ8HxwEcWwCdHz3nD/9nkwaf5f9hHXM7gKzkjHw+8I/TdaPg/G+rbzTq/sx6tkTP4 itRPGd+J86yycSb917dcErWMuATJ35N7k+nzxP+y5ksPHjPwIRX6jjO8oQ1xCeWnYx91tv8Mb2hT P/nIx0P8GbWzDG/ocOxr/uasQ0XtAoP/VeRhFlHk4/vW4H/1xikD4oIc82uQvEH1Y1blW7h5e41c MuNsqBMKXLtRvdg4j4T6jd0jHpPqxcZ5SN7SzMu76wkbOaMXrcNQZ30gbr+c+F+WZ8Cb7+v2exs5 cw72ot9XZt1AOk6C/wVdZ7p/Z7yGkTv02aVAluSJ+7WOwyl34n9OADHN34QcOycMb2jX+j6jP/Ak Uj+f4Q3tP0Xs/zbroIIX3MglI9dQT7GBt4L3Z/TyzqvLH+TO++HSR02Q++C3MbyhHfEPdeJH/L1y 4n/jnVrlPKuo11OovWt4Q4fDTcebcM5Tv5vhDe2Im2+Il3vw2xje0FFwKbw0rxV2D+3vvFc64j8b /FqTb9vIGX2q3dmkQNOjP8TwhnbEjTYpAPBBzt63Tddnjx/OM4L/aZ521XfOgHXYejH4n0c+Qr/5 hRvT54n/ZcXRpP4VzqXAzvkT/5t5Gpdc7pBj827xP2n/l5ajFXvQMb1Y/E9greGHBv9SL2ycJ/5X Jz+fl4S1Xzcf4CF34n9VaHRe6s8qz35Fwhs686u8xs9zHOHE/+rMh9RAdpFj837if3c9Ny9EVvJ9 TJ8n/lfV/hM8DnmKjo3zxP+qlC9SfA18OtSvb3lDewB+mxV3aht+NPP4SLyp8LuNMueKP4TNXor4 dzYf787Tr6j/lzuVS6ec5p1p4bhfml7O5M58POUF91rgwOBxt5zJx4OHeSRW+Q/9mXy8EO5xIq8u MDmTjxf81Avysgrt77DP+o96fCcOf77H3nInXnXnKSbVZ+PzYHC82oFXVeT7Fi534niKBwycC++A zf685QyO1zxwtdzWup1G7tRLbRNXA85c6bwbHK8pzhx+Zrx+TUzO8HhWWCbv/ui8n3aW17j7G6+U sEwiZ8/5pPPuJt99ov1ZHC9NPzR4ePj8WRwvoR5fRz7Q9n5/yxm/d0I9sDrzO6g+LY6nvFReCiL+ uvlfjJzF8YriK+DpdnxdExyvaX8Nfgb+fbZOk9ZV88gveBonwfEUR69unp8vJmf9tA71KT38PZXu I+undUXHWfHu8Gy9WBxP8hZknfUP64zk43mn9fFyxTuHyyUzTtybuYOXn+mT5OM54L7K23Xgcbec 9e86xCEV5bvQv7NyVp8B+Bi+z9P+LI7niuJ4qP8e6H4g+XhSN3XgSHPe2Xoh+XgO9TfrxPEyk7P5 eL5Ovlj4Tek4bT6eazhfmL/1lrPvcOAr/Y5LYPuW5OMpL4eXQAaDx73ljD5nvFQta1ylkSPrDOul fuqP4Hg9495EPgnVp/XvpokjuPhh357nfP4pE8dz4P+k+8j6aUtFnTTw/nTen/HT5j75cFUv9H43 OF6GXzHe+Sv0fjc4XgavZpx1Qh/k7Dt8/JXk4235xUaO6FPxI4/1Qu9pg+Ml7NuB4618zUbO4FWK O4z6ZfDzUX3afLwIHLaD9y7Q9Wnz8dR+fMvR85rk42kdgCgB8B/kjF407j7e7/fI1ifB8ZQnKt5+ hsDOCZKPN+sitrzyARo5u/+iX78P/JGnnH0fib9Hy+fIOd/oOC2OJ3xigouDH5OtF4LjFfDooq6e T1SfFsfTPJIE/7ekzxA5i+PVoHhjwbmUqF4sjqf6SLM+3oOc9beqP+tdt4zaZwbHKxJoLOOsJL7g LWf0EsG/W3Wdgf/zlDvP+YlvFvDXTx4eI2f0EpHXGsHPUKhezPvdo457gL+HvzsIjheq5jNH1L+l dqvB8cq7nhTq/CS6rm2+tvLJZSkEJ+cgHafN147g7b357uk4bb72rEekfN1HvM0tR3g8kXftlQfE b3jjW874FRX3rddDnPhp33IGx6vg1XSTl4OuT4vjtQ7+yAy7lX6fxfEq8vjcxrN3yBEeT9S9ymXW 8eNyBo8T3rPRX1vrJhk5o89ekL85x8nWi8HjGuJ7Bt4FHIGdE6SOX0edLT/js9g6I3icnjhN4xOc pMkROYLHdfUnV+TNVzpOi8fpfVRnnHFvvD+LxwG36OA5oX4NhscF/Vnry+Jxbzmrl1hfG/5H9Xm8 A6racVIva/IlsHOX8HhG4JRt9sflDn12CRTV/Ov2fP8RPE73XxOD8tcZb3rLnfdDV95IwceQr0bn weJxHfWWEvB3al8TPK4n9DdxZnYuETyuAScp8z6i32fxOI1ba6iP8fR95znfUa91jBN8HnS/23w8 ybMY+DTwOOoPIfl4Xu/N7HCe0XuM8HhqfEFHnv8R3/qWS2acRfMbvSfxGm85m3dWNb/Rw27l+9bm 4+k91JUf7HHebT6e3s99vnO4f4nk4+Va8H3gK2H3GMnHU36GLsDHo14MHqcXs+DTiOOkdo/B44IA r8qL+8EfSer4yci70Mbo/cfOXVbHD/dmnecZm4cTj2sS5vhSHEh54ej8MZ5EwRFuvu09D+WWM3ln wc/6eMgfo+euzcfzWpdNgeJfNy/cKWfwuBtf6cgHonaWzcfzbY5z7lsqZ/Si9a7evL0P/Rm9+A6c JOD76HvT4nGlwZ/VFXfqFAey+Xj3/Indc/aX8O9sXp3GwQ8+f9esX+Mtl065Ar1IXfUzH+gtZ/Pq IuQq6iImJmfz6jzyDYVX/Mz/e8uZvLq5Xu7vo3ImP+7GbwvwYq4Xg6tlsaCu6wh8qrt9/ZY78aOk dcOD8pjddR9POYOrpbu+YVF9VjrvBldLEXiAQz3MRvVicLUcZr06rcdeO+3P4GqpY7934HGd6tPg aikjr84pb31tVC8GV0sSPyj5brpeGl1nFlcbBVCF51TGK/QXRI7ETwSZ95EO+2E/nHbW1R/yQhxw p83/8pZLp1zJ6mf38Atvcf5vuWb6c4rHOfAlbOfgLXfaWR73tD5wnvs739MTj/F3nRi+38/3NPgn vDown/s739Me9pImmBp/wVvO4GrDIS/rG/lxlcrZ/DiJ0xC8EXWB6ffZ/Dit3+cR/zt5XA45lh+n 54vDu2qPR3nLGZzSA8fzqDPSeX/JjDPqOO94YS5n9Olw33r4eyrTC8mPm7hMwnopbD8YXC3AD+J/ tJ6mbCcid76nr3008xuBy9Bz3uBqHjx7XgKQTD7zW87sP4lj8KjL4Gcd6VPufE97+D0HTz74Kuk4 z/e0R5y4F0L5x/1H6uNJPMOaH8f2n8HVPHjh1JFs4vneckSf+nPycUa6zs73tAfuBDvrjDu85c73 dMC7eObXHfjKW86sM40PiVovy2n9Yytn4ydaVBx21rdwVC+Wz9h5rRtY6qf1YvmM9XwJM9/QRfp9 ls9Y65gGtetOHOgtZ/XSlAc54x6j5yDB1eSerlrn5dfNC27kjD41H3bm4V7DpnqxcRcBeckdPG2J fp+9HwJwJ/jPWqf6tPeD8qVFCdQZ/QW6Xuz9EDL4aVt9ljO4WrjrknqNz+qRy1m9gGcW8ew9sO8z uFoAXx7qkj72Z895qYsndUnVrxjZejG4WvpJs+4q8nMqHafF1cSOzOCb8Ro3R+QMTqknR7r5tum+ Nbhauuu8ZvBZFXYuGVwtAUeIdx5Ypv2d90NCPZpLTr+P35sGV0vw78afgvwq+u4wuFoSwhHlTSf+ kLec0YvWOYuT14jbEwZXi6inGLHvJy/jKWfjJ3rTupYzL6tRvdg8aBcUx4sBfmE6f8ZvI37LwXci 74czDvAtZ/Tpu+KpYdYvpvNu74eOPNMEvVD7xeBqUQhwlQdb54HvW3s/dNx/GfzQ9H43uNolh/Ms A1+h94rB1WZd2bsu6Z7f/5ZLRq5rnumsF8nPs/OcL8qTMXBf9SuCl/GUO8/5kZcDPFzfK9yONLha wX15x094+g5P+q9X+0zspVGebcYnUzmDx4mdM945nsV/vuXsPLg5TsTbsH1r8Lh33VzkU3pqlxs8 rqDeZ0Q+5tUfW2cGj8vIM00/DXmmW37AW87s95lnmrc6r6fceT9k5FWNerbIB6L6tPeD9jfG6T/J Wd4Dv+dBe3aeGTxu5t2mH90pRx77W87Esei8Ja3L52f9uFMuvY51Jmaq+L2jrjP6vjV4XMJ5NvSJ vMgXlTv0OfJLweveEVdJ15mtu5qa8jWjrpDj68zyJ8egPN2ZxUe+5WweZtf4iYz4F2rXGTyuqv0o 8Qzg16DzbnmQk/Por3/qz+glRv2+lEg87S3HeJAz5gF5wuzcNflx77rcGe/UQsdp8bgycZL5fmD3 g8mPK8BRiyTAiF3H+7PnGfKEnf/wTjX5ceWad/DIq1+Y37cmP64gXzDPc5e/q0x+XLn3w9zvdJwm P66gjmIG/nvEyb3ljF4S1ksv7ZOcibvQPJubnx380Kec5UGevLaxfPATEX7MmR/eZlw6W58Ejyt6 b5bJ05aYPk88rku66EvwONQ5p3qxeFyQOm4e9S3P/LFbzuJxM87Yzf3AziWLxwUHHKiDV5P6TUl+ 3Myv6uAtpO93i8eFGT/vQn/GgRgeh7ysDl5NOk6Lx6XJPy9xT07SPKycxeOUN7QqfvBoT9j8OM0P 90psY/L4Jj8m430VPtyoeeL3uyPr3898PDn8N3tQX7xVttOSF3nI5dcul+Q6Ep6FADm1dyE38/hI fLnm9w/+Jb1v89pffpILP7gx5vzBf5Z3vdj9AIsN8fq3PiF3t2/yBoH/+VmvvGo8ipFLp1yf/fW1 zp2RO/EqICdeCs69885OOVvHb+Jqki98r2sjd+YN9gS5yZdXqJzJG6x55suEuuRTGrnjnEf9gK76 ePuTjVw75XRnjbpC7cM8sDp+qJOmfvamPCdGrpj+wsx7UX7aSOVsHT9flZdRcC6n+SVEzuolq7/V aV4y6vgZOaMX31A30GGcVJ+2jp/wxwvv5OuDXs79F+/8OPDJ+ULlLL4Zdd3Iu+EdP2HkTJ6N2oGD Z3GNwzVyyYwzoa5eAF7F+zN+Dc2rG3l54M9qTI7U8UPdxzT58ug8WL9GAX+k+sOe5Egdv4J1jfyH Rvef5XdLCd8HHO9BzuglIm8J70bk1Z1ypI6f03O+V/DB0/Vi8wYj/HwtheU9fch94P/0m51l5Iw+ NU48SiGGd5yqkTP61LpX0KsTdyGTM/oMXfUiebE3n/8p96GOH/h06LomeYM+VqxT8MawfUTyBhO+ z8FPG2l/pI4f5Kqr9p5+yxm96HszzvzwTvcDyRssRfUZgecEOg82b1DrbsbJw+ocXWeHPTHqq8nf w0677VYjZ/WJvLoc04fvs3mDmvcQ57sfOIKRs/sWfJxab/Lp+2w+ifIEZdwTklbL5My7MRX1TzTk T0c6TlLHD/lHGfhmYecureOHfBLgOfQ8o3X8kKeBeMxK+yN1/FD/b+aFyF9ZOZt/lODvQVwzl7P4 ZgO+KV9+12c2ctbfGnWcIa71UIyc9Ss65QPsqGfD16fNG2zgd5O8oLse3ylH6vgh76UDD4/MLqd1 /FSfTesc9MTOF1bHz8OPgrgLum9J3qD6M65xvvT7qP1C8gY76j62iRczvZC8QYkbHHX8Jq8Kmz+D bw6eNfjrAvLc6DhJnPG4L4vQlL7ecU9GzvgVc9T8Dj/rpHE541dU+6yA/2DieEbO+BUz/K2zPmxl +53U8csN9f9m/WI6D6SOX1K+vJmvVuk82LwQtevKrRd6T5M6fvpeGd8XPsyD9UOrpkZAhP/QH6nj lzSfxPeyxDMYOeKH1nwgD714ds4TfHPWt4/Kb1PoPc3q+GX1tzbwEND3Cqvjh7ylyePp6Dojdfya 8uwhr5zfm6SOn/Ij1psXzlF92jp+Gh9XZr69C3T+bJ0mjY+77hd9BwRPv8/mhSg/bZdE2HecgJEz eSGaH1xv/gJqD7I6fh77CThCpvvP5oW4vuU3+sj2O6nj16YfU+tBl8LljD713V8nr4qn72lSx095 NRc5dq8YnLJrPRqp47fmKZ5y1n+t75V618sqXM7kYUrc4Biv5iPwe5rV8SuaZ+My6qqzdU3q+Klf aqnjx/YRq+OXdX06xC8Vtq5JHb+IOpOI937oz9bxS2IXdJm4d97EKWdwSs23H/4ifVdVer6QOn4x KA9kD/g+qs/jfhh5YEH5B6W/m3/CyJm8pbG1JH9p1g+ncqSOn+C+/bpXgG/Sdc3q+Ol6acC5+DhJ HT+ndfwmr22l82Dr+Mm7WOrqvXQ/sPOM1PHTPO2rv5kfR88JW8dP8Y4uARTv+E8jZ86zBN7JPPc7 /T6DU+JloAf8OM8SHSep4xdRjw/xdfTcZXX8AuoNAjf0fJzmfpD823G+gOeL3kckb3DkdWu/qDdP x2nvB/Ffm3p8hxyr4+dR/6/lZ7vA4JTIvx3fBz8RXdcmbzDifdsnf3Kgdg/Dc4Y/MrzjcKk9z/IG kScV1C9V6fud4JRq/zvNa3VaT87IWZwyzTp+wzH4juM85dIpFzVuMFwHKfAVtq5JHb+Z15M76g2y cVqcstx8nMAR6PeROn74P9c+kndj6Wy9sDp+Gf3B7037I3X8CvytgxDunV91yhm95Aa5eR9Ru8DW 8VOcsgMne3qnkjp+9aX9FfCNCgT3NwrELXXLdrmJB1TZhoI/vJhcee1yI7x1/PuicQzvPD7ITbyR 8H8GrE95x9/+OiN34nhAMtzNH6n3tJFrp1ybuHZIS1zJKUf4P7FvG/g4M5c7cbzg7nqD/oOcyVMs btYbRDyfxmcZuV0vXetAvdfb5Lswcie+2ZCXXCLw8EDnz/J/qj3/ruPH58HyfwbgxSUjv7EwOcv/ qXm74Fm8eUON3KmX5md/DXU06Tr7xP8Zl7jfU87U8SsJ/dWI85rOu8XRhyt18Pdov/IcJ3IWx/PI H4Of72H/Mf7PpPeD8tsE9RMZuWTk6nIO3vWkjJzJK4jgxwQvo+PrhfB/vmZ/az12I2f0qfFgXgoV vuPPTjmbh5JQz23ayZnLHXpRAp27TuFdH8jIGb1InqHSmMu8axzEKcf4PzUvMmp8Vsh03hn/p+K3 qB/n6DgJjidf3BTHkXXG9hHj/8Q8KG/e9E8YOYOvaJ2mAL/I4zgNvuK95tEW4CS8P4vj+VnnrqIO HO3P5ilqvuddHw95n6ccyUOR+jIOdcGE7ovJGb141A10Wv8d/INGzuaPdc0bbODHdPT7LI6neRNe 8/Sf5Sy+Cf7PCr93oN9HcLzR0uQHuPFiI2f5VJGXXFAHjp5njP/TQ27Wb+T9kfMMvKgO/jp2nhkc L132v8ZBaJ21S590/mx8lvq9I/LIxDwncpb/MyEfQe2tGR9i5NIpN/Fb1An11J4g/J8FeHjM5cM4 Lf/nzePpIcfuFcb/ibiEWW+w0u8zOF4siuNlp+/w6rmcWWeKO0X4JWUbMjmDV4WueS8zr9VxOZs/ 5vT7Ou5Net8y/s+quOGsg+rpvrU4XkS+jFP+SEf3A8HxYgJPaQlL/ISRM3qJbuPVdPScYPyfKUIO 8QVsH5E6fqXoOmvTX8DWJ+H/1HiiJAQS77igU868+2VZSRyM3u+B3u+E/1PzYN88nvLys3IGfy/I j5t8ldReIvyfuvLSXX8ss/XC+D+RL9PTms9l5Cz+Xv3WHz3nGf9niC/LN2rkzHmmdUwTcP8Z52jk SJy/4uFh1juj82fjNSLypDrwgE7HaeM11B+VwV//YH8yHC/pz5tvlMsZfcaIeI2tjp+RM+tM8bh5 /k4+DyNn9Kl8HBl5OrOO3yln4zxmHAv4+VzhcmbfOtQNBA9Pp+84xv8ZwauJ/iLdD4T/s2CdIr+R vqcJ/2erijuVmf9A9xHh/0T9uA6edcfuacL/2YD/JcSR0Xe4xfGCfF+XcJslPtnIWf7PpPx8Hvmi nY2T8X9iPjzOQcfOa1aPz804iLrk355ypB4f+D8nf2uk4yT8n8ApE3A1/n02XkP5GKvWG3QyjUzO 4OgJ62UUbHnnFRg5mweWFeea9X35/D3zf8q7+OYpNXJWLwXjnPwaLyZncTzxM8w4+tMf+ZYz+tQ8 Li1oJH5Tqhdbj6/PeooO64zdR4T/s6O+2vifsq5pf7Yen8S/33UAZzyYkStnf1q/YeCxrw/7lvB/ OvSH85q+Uxn/5+TxxH300J/VC8Z5ny9UL7YeX5n91bU+s5Erpz61vkhDvuLMbzzlbL5h1POszrhR al8zHA88pRnvcMVvjZzB8SaP5+TFoX4whuNVxX01j2zyL51yBMfLivvGuPJ7Gzmrz6DzONc1fccR HK8Anw5xjSMzcmadvfvDO4DLWbx41m/EfdvYeUbq8fWucQlt3its3gmON+vqoR5fpX43i+Opx6kL LKN+DbaPbD0+4W2RenzqD2mRjdPmV8WocmIOjHPQs3XG+D8nPgZ+TOpPJvyfuoKc+ludpEsRuXLK xY58pwB8hZ7XLN8QeZgdeByXM3qBJ1Udiu+8l1POnBNlxpV45DdSf4/NN+y4x2LX+et03gn/p/CN dI1zk7igVZ/PvK94gTrN8x68jKs9MfMb7TtVcJ9Rp0ItGykLYOXYPnKK21fFEdy2H8qD3DjfwXse kUe02bv3v1Pv4y0XR93xOt5p1/mJOuByTug/eOObef++63kjFk29zvfyUrz4ReTqa5dT94vgm9Li zc8HOX+P0+Cbeeanon7jNs63nMU3gTdm5JnWF5Uz+GbB/uuah4L9cMoRfBPxBQ1ymcvt90O9rjHs v3kOejpOi29G6GUURHnnQRs5g296HW9K+r7FO8DIGRyv68/qgIt6+n0E30Q8QwU+Xei8W3wTO/kn a55U1fyjU47gmxNvxLuqUX1afPOWg7+88v7O9VLd/D7N2y2N6tPgmxofIP0pvlm43GG3gpevoa6X /4mV7ofjHMxCE/W668Te57WRI3X8FN+EPR80f9rIGXxTefIQp+r1HULkDB4wcdE8+fzp9xF8U+Lr xoNR3++R9vdc3xD+M9iDp5zlYVX+F6/8NiMuiM4fwTfB/1lSWeLWjJzRi7z7RlzRnHc6f5Znr4uf 9brHMH/8PHuqb3itN/iv6b5leYpV1xn48sCjZOQsvlkr9KL4UWTzzvDNrDyQk4e1sH1L6xvqvE/e mMj0SXhYI+r4FbwfCpc79Pnm4yzg/6TnLsE3ZxyLV1wtNqpPUt+wAd9MK3+WkbO4L3hKZz6sp/2R +oaoF6n32cT/jJxZZx48zxV1wOm9wvBNtUN6RD5spOuT1DcEv3AJ8cM6O/0aQQiQFYfFvPNx2vMM vLZ3/ATtj+CbFee9vt99ofNA6huibqDGB806DqecxTfzrKuH/PcHOYtvZuCNdcUbjZzFN6POR5x4 I+2P4Jtl4/XzfP8Rnj3kCfsZ10zPCYtvys8q5UnU3qXfR/LYq/6c55Jn9xHFN4GLxjW+3MhZfDOV 17s+4ow/O+UsvpnAf+aQ3x/YfcTqG3rgqZOXmM0frW+o/IOu+uf+CL4ZoM/WgFOy/W7wzZFfjPqG FXWa6DgZvglezeCXPG8jZ/ZfDbofKvjWqJ3F6r+nl9Y3xLuxs3OC4Jul6fxlnBOJzTvDN5PisIp7 TD+fkTO4U+2KpybUG6TnGa1vCJ493Ld0fRJ8s0blvSuop8i/7zzns8YBCu6L9y2dB8vDWsBXWWD3 OPp9Ft/U/PUEvq9ZL/KUI/hmQF4y6hHxeSf1DYPieKnpOKkdSeob4h1eKvDNQvVJ8E2n+F+c9iD9 PlLfMAM37P753GX4Zp+8d6gfTuXs/eBRhzFr/Q7gK0bO4ptZf6IeUafvAIZvAk/1iHej/gla33Cu 75WH1cgZfLOC361s+XGnHME3Iefc6qc1chbfRN1A9QRNPoFDjtQ3zMA3+4w/Y/NH6xuqXj32kfyF lbP5xQX5qRX8E+z7CJ9qiSoXJo7H9gPDN6Pi9h18CfSeJvim8vYOXBz5OWz+CL6p58sbN6T3EclT dMCLK3jrPZ0HUt/QKX7kUd+QnvME31RejiqEDo/7j+CbWudl4LB4F9NxkjzFcY415Xkafn3PziWG b2bVZ1c/dKf7ltU3dMhLhp2c6PwRfLMDX9G6NNzvRvBNXekNdSAmbmjkDL7ZZp3CtuJOpxzBN4HH oc4y+DyMnNFLj8DxkI/Ox3me8w3vsHY9bFGvgI7T5qMrL0dTP9HjvmX4ZnrvI695YVbO5inKyTH8 mfCfUf8SqW9YBC9seP9LmgCTM/im1lHpN38PPecJvqnxbv2uK0Tf/ay+YVY8NeL9wPVJ8M2MeoMR dQrZOA2fatd8M5GDPf+ichbfzJrX6sCvQe1IVt+wID4Efo3GziWGyxTV5x3vzead8KkCNyyzfgdd LyxPUfPVys5TeshZfLNkzT9KyF9pnp1nBOeS/9M1jkjwTTZOi2/GOPO54H+h64Xgmw14R/XgO2T7 nfCp6k72ArT8uvk4DzmGb048B7yTic37iW+OcsDAcwrwW7o+Lb4p73zNB/JLPuUhR+obCv98kzDx hRfnlLN6mfE9OJf6tj4nLmrxgDLwzIHj+XmeredSnnIWj5v1DYGH1+2efstZPO7W52vJ3zRyNt9w rpe28nGecgSPw7xTPO4tV065cOcpYn16JmfwuJyhF4lnuXlmjZzFnTTvDHys1/mSqZzB45TpVh0M Y79v9uAtZ/E4mfeBV1XEF1QqZ/A4zfsMkuj4LEfwONQbzOCLbVSfBo+rWk8q3LjoZr+85YxeNC42 SCKsyNH+LB4XJx6ndmvh32fxuDT8KCP9XfNCYqL9mf1354Hd+4+uF5JviLpzHu+47Vx6y9l8Q9QN LG7laTNyBI/TfC7EPe3vsVuO4HHId+qox5CpXhgeBz878jQynQeSbwhcbdaNyHQ/EDwO+UcF+Rb8 nLC8oYPAX9ab8jPESPctweOq4jKaVzLj9Y2cxUmAPxTwSgemF4LH3XlgG2+okbN5YMCBkGe6++ve chZ3iqpP+N12XO0tZ/G4Fl53ndE7H/aUs35a1wrkwic5i8fNPLdZd46dL4Q31CPfF/GKIXE5gsdh Xc96PVzO7D/Fs70kYD/uP4bHVY/vxPyxe5rhcXce30vl2D4ieFxWPK5Nu4DrheQbNuC+7fV8npF8 wwh8syp/iI/0+xgehzzMmTdB1/Xpp51+1jD3Q+DrjOBxqD+WC/Jz6PcxPA488uq38ZV+H8Hj+qw7 p++VzuUsHhcU7wjIB2rsPmJ4XJp5g8D/uJzRi/DirPmU9DwzeJzEbY57M4Ing5+DBI/rqKtXUK+H zrvF44TPT/JwwTfK+7N5dajPBR4C5+k+IvmGDXl88JdvONdbjuBxex5fZP2xfEPk8SFuxtFzguBx ir8meRCLHO/P6qUC/wP+wPsjeJzTdd0q6tWxe8zgcQX1p9LNe9DZviV4nNitWf3Wcs7T/ggel4Af 4R6L7BwkeFwFHqffKWEKTM7icRU4F+JmMu2P4HGoB1Z0HnY/5lvO6PPGx/KHc5fkG5aquGGB3RPZ PmJ1EZuul8kv7Og6I/mGwNUmTkn3EcHjAnhtA/yRheqT8EMn5Dcir7Wy84XgcUn9ivruHO8VLmf0 GcCjG1CnqVK9EDwu6PmbJj8mnQeLx0m9x4H/9TXv5ZSz+YahoV6W7qMdp3zLWTwOuFoCLyPXy3nO N/ihr42rfvZA7Tqab6g8uj3CPqPjJHhcUf7WvvE6nHIEj+vgfW0k7uktZ/E45GU51IVybB7+Wjzu LWf0WRFfjvgQT/cfyzcEXuWnX4PNA8HjKvCxkUAh806/z+Jxih+UGb+0xwG+5Qgep3l14EPq1F4i eJzwTg4cVvmQOrWXWL5hAs8sePIb1QvB44L21yOJY7nlCB4HHtaK76N2JMs3dIrLONcXHp5TzvhN JYxE6ohpfkCl+53hcQ7+ea0v0+k9ZnhD3Y/yiqnjVexPdp4Z3lD3I3jhwOPqh/1u6hv2a8KQNwi+ UWoPEjxO66o3rBt57hI5i8e1rjjsjauxc5DlG7YCOdwP9PtIvmGceYMrb+gpZ/G4HjV/Myn/daf+ OoLHFeSLVrzft3i+W87mG4LXT+I+H/3XLN8Q895xv/N5IPmGwKvclr9p5Mw6kzpSA+eCvcvnweJx qaucwzvgQc7icU1xQwceJWonk3zDiavN9xE9Xwgep3E918+Xfh/1Xxs8LsjDRvaf4pTBs31k8Lig fE3BIX5m8gWdctaeB66W88wbZOuF5BsifyzXeZ6xcVre0DDr3Dn1l/fA5sHicW/eQo1HaVQvrL5h ULmu9WVqYnIEj6vII6qob0jtXYvHJX2/j4shPfvZLR7nK/TSP80DqW/oMU6JozhxvFuO4HHoz2ve fOns+yxvqOJcIw1ax8nv6Sc8buRbeOQtrfto5vGZfLys/q846/0ceQX1QS4kCVQbP2Ne/RpiOF3W uPPlMqRiiP5v/vC/6def//KPf/rbf/yf/+aP//1fws9f/uUv/xp9uOtXKWn8vBaYW39ev669EfMf fIrRlRxdyn9wPpTk/vBy/xqDOX/985//8sd/er3+8Kd/+ON/+fTvfvf3/4f++pv/8Hd//ue//8uf X//+H/7p372wGv7mj3//X//zn/wv+XFtlL//uz9dy/m//fFf/uPf/pdLWb/+JMv7T3/3P+TnP/z9 f5p//rfjv/9G80zfaarHttA/X5tCjLzxE5eh/PXvpYfJHKrc8b9C09LbA5JPX0mPB+/VZxoXahzE 7yBM7V9I48LLct/cZTPu6+M30l3MxxAx8nI9GvQSUWPsd9JyJF8jF6rJId30ieJ531rY0ehcHJij lQ6CtkalxS1gpcXNIzOm17unIzcwSdNLXpJeGshxB4Zfv5EWranFPP6/cAX/uimtfyfdtc+ggEn8 iVV0Xjz97kNaAQONshVplJMoCif+RlrNh4wgnqK6lmAAutbOIIICqdGVXLFVr2R16Z3Sx1WnLtMk dpgS/aqBlDrdJQbIxoxFvWZbw8gdnW8Do0K6Yr4FvHdKUvxbaYA0Di6ULBjQL83AttJBE+jsSh0e DflZEHDMVssJBKLvAa9Nt1hYzMpT2oQb6Hc7GCdKNu4k1+QL6a7UGUo9O0KpcDo4NmOntH5Jn4nn fhZw5jNmpKfOtTzdXSawtm++e8IrKALthE1qzFhg831Kw0nvQeV3fYKmoufOdugpjRN5nEgNjgM9 HbjWzgfg+7t1f2eULWhsj50whO65JDniAn659OFcO6X1dKgS+aElkbFLAjsdTijDjvzTjJ0Olvse 80JrEdQ94DRM0Uofz3RIV3nVSBCt7tBKzxZDiqE71CslZsjiWx/fnb6Rvr9bCzYiQfFpj53S0EOS uFsN987Pd4mRVj1kkHk2YUuQc43dBqf0rfPkp8tWQ1roSjXSaQaad9U5HCutfiWtjp0idXSkvAfC qOg6z4cb7x75TB5wOFPlr410pTs0IxWn/uAWBNXLIX0+ufVMLfKOlVMiBiVkoDo/pect6OQey1IV Vk8HNt/tdfQ9b+BJNoMTOdP7+3xs6sibnkSamowQV3Yq9vMG1l0Sr6XZBlArSJTsb9r3eQOrdFZ6 gctGdihrG9b5nnQ3p+0wz7XacJ+BnAfkGYf006lYJ0QLqo+mt4HfR87fBteD2w/HVXQgtvzxevv/ VnpYvbEqTX0sMyzc6Xz/VnpYvUN6OHOjl2NBnJ7tC2mdwRgll2NId0B/aq/9TlpmMCYllLtaaQgE 1FeNkWbW/dDagMdixF6baZVGmln3l7SDkyMhWUCdP6c0te67ZACLFeCxzgsd+YN1D0fXZUNoYZ3K v5ta98MLCysA9HbF07VG7fPBSenlZ81wAuvZ8htp3e9LKPostaPQ6ylNLexRCAPEYCDcaoGuNWph X9L6Jz/vkhbpdz9Z2BoMUWax1xLZLnmwkQOoVYtCJnfo8ClNrdxxf+MmLigcE9h8cyvX6xNKbiSU ZRG530rPkXuAtC3gXPtKWm3HDOqcUZKwP59rD1ZuVEBMCrLpDUxPhwc7NQgvs9KJqb3W2Yw92IpB qhNoEqAWp+xsrT3Yil1TFUPUmdMIfCLNbcWuhYGHrYgCyI7N94O91vAW7MLz8EurG30hrWNp8tjX ZD1Is3PtwV7rqusBhUWUimYzxu21y7KWwsgBhEJPZyq314Lmbwydd1iahfbN7TVlE9P3GIpLUq1x e63r3hJpnTHaN7fXRn1mJCQ4LRRTlMDgkOY2U4ffYYQNp7pY90aa2UzjFhw7M46NjSBuNnJuM13S faSWiAWylsSF9Ez1ebKZCgouCEAgiQqr9FPCz5RuoAFzKPtV2nq23PAE9VKNojxBg2taV635RqS5 xySOc7zKd2tp+0khd0g/vOaGU6/Kz1nYV3do+E5rUr50fHfETaT0PeE7rUkx5/FGSB3SZZF+IpGc bwOlXMh3CD4gKEjfNjL3BCvCLYmIKEAof22kn75bPEXXyOFfw3wf0g8+j6Zk1dcZE7TYGzwHhzTf oV1LOipFl3pE+9r3hNCe3wbQeZ8rdZ3v+wR+7dJqrxQNM/tVQFfoxI1+Scdjvvk6d5I9pqQcfdHa Ic39Ldd7DKk9Dauld9b3g98hSGbQkghfw9r3XGuPK1XCG4qmsbzXOaTLb6Q1OaxI7PHyeteJfvQE 73usaMiW+FPTF9Jzl3QPyytpYlrSkR/S3CPa4bsePs2uvh7PRv50lyQlLQta3GJwL7dF+mm1zPmW kUoq1wxxrEz6SWseOq+YsbqO/Hf7uzTMd8Uu0bCN9O18t33GWiPSp9dC91wSqEJf7wjF1zdw/u67 S9cdqn6Xe7VA+neng5YRLQLN6Tpvi/TTPVaQ7BwiSCMiZkyTrA/pp/3tEeKmpRSdphwa6Udfj/7J CcO9eKHluwv+Ff710zpHWqSf4QVto0/+3ekgxXJFa3OtrWTkv11rQjFdtPTA19I3TlSRWJs0kTdt xNZT+jzPVYtZqlirvVbUd7/R2T/dRLd3LulqEVDt/Q6F9NNam33nois1FkW42kbp/Ns95mBxubLu UEjX30irvaZVSfQOHX99pneHQ2tpjjxo0JMD6XnxTPoRdUi6WmKYFIuJSPN1nnEDeY1Y/KX1ul82 EOZJa5LmM8vw3Kdi/U5rt3Sa0upXHNH1oZfL2C851B7r/7agmP8/+vXnv/zT3/7xL/+q4T+/jf9x yS3xP3HE/6T4f+N//pf8OuN/xmog4T9efg9bENCX4T9u+X05DBo4EZtCt15K2pDwgPX3VVqeqyMz oK8MdKe0W37f+g7ge0LeoP8Q/nNGAzbNeklBQcgnCG+CMIcjsGjY03hw4/HT+cjlWe73kefBkDT6 7hqKcmcuntJ++X377oTvhtb4d4f191U6T63hkf+i0m35/X5ApWvGAD6Cy5sCYSp3fvcI5AgKF3u4 APNzAM95ZUr8dJC+Uee6lQdpR3TelM0vD1YrrBYaBhOX33etIZZ61rakWkvL75t0gfRkZKVay8vv e9+o21TXOpdGemStnN9dLjN2ZKsWpW37dVcpOqXL8vu2Q5OO3CHUzPPQo9fLGpY349h1OjQwctNd oqDbuVoGsYIGyZXJK0t1LlkN5rvHCxs/5dn6FJiokN3Zd5HidCNAEcZRLzQEZ/n92KHhtTDRuUCl BQgxfYPXLzTNN77rrJ3SciYZgKNotnEok40J7IBUmvUtP5sEjb/dzVT6fApcMzb8MqOVhJDKxNZa XH7ftKarr142NPhk2WrRc+Ec+ajihCyehqqEVOeQPs+WAEdxF3T9natEpY053vUuGfAKRv7QN13n XV1gcUQVqJOehoNoPuUpHccxOGDyoIE8T2dqWn7fdT454gpy19jJpBCO6TuI73OAzfMOrWzG8vL7 3rcHr91c55/CYJrR2oCoQ0dW6cxaptJm5ElzaWIWUqFfd+4rlT7diCOowOsYQkUGEJvvsvx+2EzI A8K5Vtj9jd11nMhheLM0+LciS5+G2Km0WWtBw7wu6YacQ3oLqrTZ30EDGgYgtmWKG2m2zmOVwhrD 8grtw2qpy++H1jQLaobB0IDrWthKTQO7GhaXV5vx6VRsy+9b32naTAG3IJXu7ExNWU/k8dMhkIWd in35nfft27O1pyAcs7iqhsqj1hJyfSF9Qzrr79v9nTXMLeNMTZlIP448e30bzHpGYd3ft/Py0boH 2+ldZS8S6ecbGD89aiFvNtPtxHuysMuslImK5FvI1ZR+vseShtjNV80WkHk78R7t8zlyVL/0XLqR GRt2S0uwsHWHisAp/XgbVBdg7YHhZNX57cR7tJGRnxrwNth2yZ3/t/y+a23Od4KVu1o9tzPr0cKO cduhm4U9pR9P5DJfkn5lhIH0/e8e7fNYMWNkrc1/93iulZklPW0HGrC1/r6dDqhZO2veaE4iDVRj 79CRmX/99LjHeIjd02tOVslYa7D2Npj8t+8xqcKXNf3zvcdO6adXzSCHGq+agnXuqNaeXhbi6pWX hYaD0LCIx5eF1JEvyIe/3/40YIv03SV8V+lv3vYaDdhi9rlXiD6FstgtNHCJSAtT2bDucQvSYJJH C1vrNXSFqu91TgOXmJU7vDRRM0je9/cp/WjlDvv8sjjlBf201h7t1DKsvBiFAmRIN7bOH23FQTgp wSSwuOpzEA2xuNRWTJJJIYFLLNTs0WYKI9Ur4nS47ZZD+tnqybB6ENhQ2S55tFvEx3P9nDvU0fCf 5Xdirw0/U39eLY92i9TYCSPQXtd5Wr/7CEUhtkPWeyyBGXM71w7Y1I68J71L6vRasCAa7lfMo9qn nqkO0i09SpugkKRc9DmA8+YIwXmf54/frYwUwa8e0UP60WaStLrFa+E/hP9Y6QYW9gR2Jr39j/Cf WfP1kB6k2tA9ajbo7X+EwUD67LuDgeOSBtOkMmIe0vwlGasGS409hnqBjYXgPLwFq96dsSpr7B2K coTgYKaPkV+n4kB8JUQeL2gND4jHfD96gvHTg8FemQwO6Wc71av3vUz+2FX6trCpn2kkMyCpYcTg vV/vVNq8JK87RIL7r3tca3OituMRggO5Y7WMFFYJyByVvzDyte+yS586T4KLD+mofG4urSEZb7tl /X3DLHCugZWPhsE82OdJ1/ewPFCDQ5NQubQJnZL4NvHxVayW+ChtfFwR4X118ku3zPp+fBtkVCF3 ZWULO0JwHneochE2ITF9pyyfITj6xed8F00IDKgIc9stRxAN9ubRdxz1tKLu77JaPfnQ2uOrZr6J 2upXPKQfXzX6Bu5ykL+tniOA5/F0SEW/G4xpYFI9AnhmSJ2RFg/RCKFFfTX17R1BNI9+JmFDGjdw qosHnEqb/R2VE3JIK7c/Aq7LofOn11yMM7UP55on0s+vOZmxromR98l0BPA8nA5RIjrkJ1J/HAuD efQjC/dmuCwu+Hr0/U2lmR8ZjGA9rrf/If24zoU3+bJXJUnt7PvYJc5IS3XfCDazG3U4g2jU3jn6 zoOzvqndAi6sjYvu/Zpbft/3GPCxCHTNE+lnzyASDBJ4ozZ+wMPaIwiXn1YP1trrUZqcih6eA4Tv jly91xMXzTljSfseL4vil5dFpTo/ZiyjXnEevOx1OVPFJRzd9WByl1kUfQ7/NwTn/+W/RsTHvzL9 z+f4n3A9PPwa/5Mk/qeG/xv/87/il43/+YL+56+K/FlOrZ8mYZaXGT3rwakv5kTWD7kZvJ6V1/ad wnXKnefc9ZjVdBytO3Knhhg5w9tVJ0WRW2+VU+70TCLQveI778DnUy4YuaBhqJMyhBMxnFa9unBF Tt/Ak1f1lIumv6QJN5MWplT6fcnIBQ3dbKhj9aDP45ZOGn8hdU0RjJ4YZmrrsETUD/SoS1QoQm0C bDW1cfTbtT8eTWDDuBGTNn8+RH6c7+FB85xeGkY954GN87T5BrwnPhspy662LsOxT9shSyaEptkh +Jcj2FYuqlyadW1oVI1J8qqS1ybJvqiX3Zg+T3v6vc6UsdP9VKrP8w1QJbNJEoQ68D9K73Hac0mJ uC65POuepUrkTut5wKuaFOTcXNdMn6enMksYnaSOp5km8QEjXc8z2e8ZiY5Kt/iEjrL+2gwZ38Z5 4KLrPCAZpFbIbfj5Y6C6pjeNft08dxmaSc7BoPNe72QEhqHafeTnvt2TdU4E09Q9C1rHymsdj5H6 GKhcOuS0vyGnPObVUcTU1D0Ls45ciSAjY9QYpO6ZprR4rav52J+pe4bKAiO7QQmptnP3xIXX/a7r Jc56HFts0lvO6DMj3auW/qm/U5+63z1iJm6+fI5Av88XJ0SxI/FXbwCtd2jlTL20yawsIbiSBEHn wdRLy1p/LtwEAvJXRs7US8sub/Ow0++85dI5ztxmf/GDPk29tKR13dSxLPYS/b5s9NKwPqXeiJNA JyZ36iWW2Z9iRi3TeTD3dBJUtP3Emcia6TjPhG0Qbo2ALNTp4uO09dKK8JHHmb6yxxq+5U6qEtR5 DXdd4Ubn3dZLqw51wRQr94HLGXuiYpweZE/8+2y9tJK07pJPqNNFv++sk/AeZ9BYBh/pOXjWSQiI pwtyYYovgn7fmTKfxXEg+0HrbMdG+zvrJARhzZD6NOAj3wiZppytl1aaJnMq6uc0wZLIGX1q3blB FxYWDNjIGX0K3/04rxVb8o73Z/Qp/pXRX0Z/nsmddtY4x1AvTe1I79n+M/XSFjmMk0b+mHppcx+N 2DbF7TpbZ6ZeWhInnchp/kSg95iplzbriUUpoCt6YeuF1EtzqLvkKqGKfcuVU05juLwESsr3sXPX 1ktLUe3BWfel8Pmz9dKUBzsq7cUZtf6WS0ZOYnGCxnWe9vVbzuhTo8wC6sgfdvItd9ZJAJHpkNM6 a6izbeQOfVbEb0SNyLjmnZ4vpl5aQURaloecvI9of7YejpNIgATC3VmnxMidpFI/3itFQHCo80T7 s/VwPOqCoZ6R5/N3nvNF6dnGeYa65YnuI7GGt3WG91G57TP6fef9MPrT+lB+q1tn5A59ZtRVSDOy Qv/OyrVTTj3d6V0niO53Wy/NV61LJHbF4zlv66V5uWez5lLcGNAhR+qlzXmvSg3RM5cz55nSG2St X+AERGFyzchlre915zyweTD10pJSQA/CMvj+M5czetH6suPBqnZP+oaSr/xo5ZmspE2/7jrpRu7Q J/JIxjhRB4Kua1MvrSKvrty895mdS6ReWhf/QkE91Sc5Wy9NePbHOkNmGrVDTL20Kulzcs50PZfo e9PUS6vApLPSYXhJcWJyRi8OFD0z0oW+c0i9NM3byzeyWOg4z3N+Rkhe6yXAbqX7wdZLU00p14jJ YbrljndAkc+SexP1zmuj68XeD7quizgc3tEJRs7cD1qvp0jIkIkTf8sZfcaGemIFeRRUL/Z+mHpx yGKg9pmpl1ZAqVje9RhfTM6e84puFtl474gRI7frJehFeRNYP72rTL20Lo5rzcmFn4/2d57zXXim FQnV+6HT/Xee811zSaTOl9qtke330/+ZtP7UoDFwus4aPa/POmuXOicleZ7+QTZOU2et/+iMjigx tZPpuWvqrHXUt7wu+Ix64Gx9mjprHXWWy6zP7ek73NRZ66i7W1EfWoBpJmfOwY6CBhF1y6mdReqs haLEfChG0Oh6IXXWoteMnEnaQd/hpM5azFqHrIPKj56DtM7a1Kv6Nei7kdRZm1TPCbHDkfZ3vB+G /1nPQQ8CnJ3E/S1n9Kl6GTHaahdQu+6sszboqJDDMArxvKN1jdwRFRbwHgNh7uBnovvhuFcGMaHT +etaH9hR++ysszZIFOW87hJAZnLAb7njfpD+9PsyKHmpH/OssxaU41JIDHHu0nfAWWdtyo04Xn0X 83fAWWdtyCGKdtYRd/Q8s3XWQtEo1Dbrk9L9d7wfiqSkCXn8TQJD+7N11qpD3UGN1/WFnhPn++E6 B33Bd6r9Sd+NZ521sc8l93/wpfVne/esszb6axo5GMOH+/2sszbkspJX9vTBTj7rrIkczrP84b4l ddYK6rppxN+MBDJyZp05FD0Qv5RXonIrZ8jolPBXssVlXUdqJ5911sr1ztT7L3c9l2pl+++ss1Yk qU3qn028kdpLZ521AoJiPT51fbL+SJ01wZ2qlGd/PfonzjprVUuMCI2V+r1rYuM866wNOeAWETTr tL+zzlpVwmUhf24gvWbn7llnbcihv5BXsuxTLhm5MuVce8YtbJ01JTsc3wechPrdzjpro+wqcISo eECl56ets6YjaCDl8rMeMeSObMANr9J+44wT2PyKex7gag822IMV66xteP+RAbj1B7ram/yzErkT 1x44v+K3N7n9ts7efhPTH3DYBLu1bufErXfSX9X+ovpRWmYZMQRnTirngIcjVp7m+L3l4vXO7Eok n5ETWVjmkY1HqVXvo4rzpVOKaYIfBY3zkDibNz595qZZvXidhximf+k5p23zoxQ5b4PW+fXiTrNy Nl5DLfyidsuYB/WXn7lkLyNXy7LvnZL1/ZYGOnjNYRK7Tu2JD/lj675Nvr/exWXuSOQze8uOM6rd KnVsf93UbDRva5XzTfuTOJRfN13kmXP1OH8B8Vl9y/Q68oaW/mLQfdRuqsR13sOz3Ix7kr9xktz3 esrPeu+HpMUc4igfhlzZdR7udWXjEjzO3d5wHzUql065Gc/QNLq3bOvsLWfiEsSP7DWV6Nddv/OU s3EJijcNmvI1DsLInXEJQUsm+Ps+ilQvJr4AkQoa7C1yVC82vsCBtjAoj1MNXM7GFwz/YBfYSeeP fp+NL9D7b+T7gFLbU7mH+IKodX7V7CVyJr4AlvMoPVL03Uj1aeMLPMbpCwoiZCpn4guk6NRYZ+p3 q52O08QXxAK52iFH16eNL+iIf2mawfwgZ+8HsSOaVBZT3PdF5QwelxCvkTR3KGzZu2+5w54PYHEI +m7RsrZMzuC+NWp8AQhBe6f9sfgCxf9c0HdA5nIG99Xc/aD1xMcxQ9cniS9AnKNHfF3ickYvkj03 i7x4JWwnckYvml0afkJdGTlOORtf4MUfNXJiRC56LmfjC7D/QiAZ4+/31+tcZx3rbMbXNS5n9NlQ jsyDFaCyfUvjCxAfEla/jZEz+uyCW0QJ7BI/GDsHWXxBwrmEYhY9UDmyzrrKgUGnsPVJ4gsq8GIP zqDK1ouJL4j6bh/rRrnjvOP9kfiCjHmPSxzLKWfjCzzK6Pm532l/JL4A+HsJ9Xkf2fiCXPTdIXo0 9uBbzpxnwXec88jbYecSiy/wOs7aVlYaI2f1Wed5iP1O5Wx8wSwJWZBVzfVJ4guq4o1VcS5f6feR +AKv8UQdOWT0fmDxBVELfTrwIxben40vQAmCiixivo9YfIGeawE4XqbzTuILvMZBVOCbfF3b+IKI ONysdnl1dH2e90NGfEgSLu4P/Vl9Fh1nAadrp+vFxheEDn1ifUZmv7D4gqTxBTnrvqV2K4kv0LiX fI1zLWV4yJH4Ap23rPGqTvMuiJyJL3BtwW+d1Jhhcia+QIrJDf1gnPTeNPEF1/7riLeBnGf7j8QX tKTxBRnvsUy/z/gVs9gRBe//O67LyJn4Ah9VL+A/8vScMPEFWlFBcfHyfJ6Z+IIqBoTKAX+gchY/ UnbGfLPX0fOFxBfovh2JL/XDOEl8QdZ11pB/RO0CE19QfrRQdRaO9cfzhcUXYH3WgrgLOn8svgDx PfDT0vuIxBekqDhegv2S6Lo2fmj1vHfF699xxkbO3A8xKy4aJ65Gx2nvh4T4kAAWO3q+kPiCJP6l qnGcN254ytn7QYvDFqzTg33mLWfjNSA34wQcOz9JfEFx6A94v6fr08YXaPznNV7df6HScVocqAIf S2D2oXYrjS9QvGPaE4XdYyy+ICn+3icex/Ri4wSKw/vWKYeQeoasnMWPwHRRwStO71sSJ1AnRzTk GpsHEifgweGWYb902h+JE4haxqiAj4ueuyZOoAF30iojj/YSiROIXnkVkjLNNmovsTiBpPpEYZFG 3+8sTiDBbwoOCervIXECadjxwSlz5Flw7y1n4wTAX1hgF1B/j40TKDNfBnkahfp7WJxAUeaB6IFv sn1E4wQ8xhmX+EgjZ+MEOuZf2YJCoOuMxAkk1WeAX4PefyROoKKcO95//BwkcQItgZMYdmuj82Dj BGrP7/H6yU5r5Ax+W5Py8UbgJNTPQOIEAnhGIuLS6f3H4gSaxk9EsHRtBX5vORMnoLiv9++yRnS9 kDgBsKFh/nyk+iRxAkXjBFoBmzedPxInML4v6EPzHfd7ypE4gaL4O0qjgUnLyNk4gaJlSYGLdupP ZnECVddZg51M3zkkTkBxnD7Lx3G/DYsTCCqvdv3MKzjlbJxAdXpOVOn/J1Z2/9k4gVzmetG4p0z1 SeIE9P+MeBbRS6Hnro0TUPxolAXWeMxM7z8WJ6A/R2V23UdMn2ecgJZkkO8DJ2Sl5zyJE6jQS9F4 t0L9EyROIE1cRu3PvTTnPS4bJyD47ehv4nGsPxInkGa+6MQfqJyJEygOZcC67r/S2XqxcQI6D14D e35pmBeRs3ECUf2tNcCe0LxdBfA+8Dr4rviflE9+4wGH3IkXRy0kO3BH8AnUuvL1+dkfwRvVj9Ka fy14Y1j6kXG6Qy94GWgil+QRRSqXTrmK/VBQ4nIrzvmWa6dchj2BuIS9mOktd5wTFaXXxv4Dfttp AdbDHrzk1M8+ysYp7uSoXoLRS9r3O9aLkTN6meXDk3IeoqihkTtxUT0Zu6RT6r3imdxhDw4CdXkH hKtjnb9G5+GwBweRJc6Jrv4e5PWccunERVOdeFz7KHfiomnit80j/53qM516UVxtjDOu+einXD71 ggicqz+cn7y/bPUC/HZ08+vORz/lzP4riNt2mL+HdWYKQouBKyUlRa/yvGJyychBLz4hH4GP87Bf vFRu1n7BZPpicue738Pfo4b8B7li5MQ/5G7uU0e/73z3jw6y3g8FlX3o9512nQKT8hP+Akf30WnX IZ9c9BIWfOWUO+26wecg+eFZ50PoeJic0Yv6rb3Gt9441yFH4okkjlZJ1Rb785SzuKH8+6b5IHJO ML0Y3PA9Tg+/YqLjPO1ID9x3OExXrn4jZ9ZnkXnzyOebjPGn3Okv8Ijb9uqvu/FbI2fnAfZLnLWv 2DozuKHXuk1DDjhXYOvF4IZDH17WmVaPknRhJmf0onq81gsYSjOdv9Nf4MUQkZ8Z/IFUL6e/YDjM VG6y0HI5gxtqfFZdSkDTeT/9BV4IivR8eX2Yh9Nf4MHu76SS7zvfycg96NPd+QGerrPTn+yBwyJe So8pJmfx/qDxGpN/idoFBjcMEvgrchV+Brr/bHxICxrPUJCnSO8/gxvOOIEgF7vI0XVm40NaUblZ ZaLQcRL+ia68Dn7iAXTeSV4y8OlZ9rrR9WnjSnBj3NXqMp0/G1fSwMvhJ/5A19l5rwwenQ55vVf4 PiL3StK4hKj+wUbtcoMbXuefrOc4/RONnvMGN5xyYz5e6v9k32dwQy/Amsgh34J+n8ENPeqpBAn0 Fjk27wY3vMaJOJ2qcWSN3tMGN/RgUQ9CvCT9sf1A8pIlvi5rvK/E4dLvO++Hmdc/4vJ0vxe2zgxu mO44jz73H/2+835IyNMY8Rfoj47zvB+S5q8POdhLfJzn/ZC0pprEpbTne8zghgns/aM//b5Kx3me 8zP//ZLLuv8K78/mvyMuKMAuKOycN7jhiCtXvgSxX+/8WyNn4m2mHN5/3D6zuKFG8Df1R4m/h+qF 8BMhfmk4Qn7dHPtGzsTbaM3PqPw/Z12At5yJt0l9yqk/stH1ct4PEXm+8bZ3qV1gcMMoCTYiF+oS P3jKned8lEC5TY7q08aHaN3ZBHkpTcLkDJ7qwEOAvCzv6Dyc53xRPoexL9QO8dRuNbhhkYAeiUtA jaDC9GlxQ83r6IgjvP11Rs7gsA68HNMuoH4bgxsWIUgQOVQybEyfBjfM+v6WODvFRen7weCGRQBG 2bf6fvCJzYPBDdNPbuDzQH4qPQcNbpiQF64EohI/SMdpz/kp12a9QN6fOc80TnXIIR6Tfp8956WK 5fVzvleo38bghgnxFklx0WGX03Fa3FD819c6A59jpXarwQ2vcSbsIzCWUzvZ4IYJ+ejpZ/LMUv/E iRuOOJau8XXg/fH0HXfihgNfdhqfFeEXpv7IEzcUOY1HcboffKB6Oc/5qnyMY51hP1Tan40PET/5 kJt8a3S/n+d8/XHQa5t8QVQvNj5E42I1cebXzTNk5Aw+7cLkm2kf9q3NLxZ/ZL+OefBgVXbfnrih R/3lEUe21dQzcumUK03P3Q5We3qvGNww452TfwLiSiKVs/HlrYBPB++VSMd53g8Z5+0lh30UmD4N bpgl4UF4OdIHvRjcMANvRE2rJ//LiRuO78PPCDuS+nsM328TglqJD1J7l+9bghtKvGlXnONxvRDc sEIuQY766yxuKPDikJv5m/Sct/lxZeanAu8A/+4pZ/GxBHxs5hdHJmdxQ/EHir/V+SWP6JQzuOEd H1LzBzmLG5Z896f5OdResrhhmfm+Naclj+iUs3rJpxybP4IbTlx05vtyOaOXKPm+DXxDd5wO5GZe sn1vRuEvK5qnJnEJgcgZHD0irrlNXr+w2XVHNZ1t/8Ww2AcSPvOWe+cb2rxB4EBd43TKZte95Ux+ nEfeYFU/+47jveUe8gY1oOuXlhMnciRv0Ktc6dXiMm85mzeIccoMjX1Ev8/yEteJp2oeSt3s1rec 0Yvk64rfVXG1Df97y9m8wS55g01X0nHO33Ikb1D0Eue+LY3Ow3PeoAcvwHbO33Ikb3DOe0PeIJ0H mzdY8O5Hfavq6Tht3mDAvDete1c77c/yEs+4ErkH9XhiciZvUE8qr36bm1fslLO4YVNcZuK+pdN1 xvIGldcWfB6h0fXC8gY1D6zBP+G5HMkbBL+p9/bdccuxvEHFgfpWL9rIkXwuyXC+3jnAN+k8MF5i zcsKsHsiXZ/Wv6t4ToC/aMa7GTmbN9jUrxh9svbSLUd4iUvDOajxyfz7GC8x+A4reLOZHMH/kvKj OPA6FLpeaN6g+l9mfkflciRvEPmGs6I9238sbzCqPys4vIvZemF5g37yba9VcI2c1WcrWNcqp3lE pxzhJYY/S+I4b35vI2fzbMDrkLT6uqfnNckb1DyUNOO9O72PWN6gbzivgTPT/kjeYFU8p8BvSvcD w//GCKrWpXteZ4SX2CMPEzwgnerT5g067L8243d5f1afbvKJk/fRLUfyBpPKFeQX0/Oa8hLruxj7 3Rcqx/IGkZeFd2qk42R5g/q+DeAVy3T/MV5i9V9X5FPSe5PkDQbwhgacn3w/2LwQh3zKhrq89N5k eYNV1tl8x+1xQW85q0/wIHfopdF1TfIGu+7fCp6vTs9dkjeY1b4uwDcTlSN5g1HzXjzqI/Dzk+QN dp33onUxkDd4yDFeYqwXB395YvuI8RJ75DdOnnw2D4yXuKo/JMKeCIXJWV5i3zTPbfKxbO/bt5zR SwraX1Z99sD2H8H/5B1QlB9D4i7o99m8Qcnvlvn7cM4TXmKXwKsJnIvayYyX2CGPD3aWZ+uM8hLr /DXkFdD7nfESix95JCLV5/OT5Q1ifTacE/R+Z7zEXs+XQQj3Qc7opWDea1x5K045kjeIcxf5xd5R vZC8waDyReMjO9eL8S+lMuNp1R9SNv/1W87mDcq5WzVP4+bjNHLmPItF14uf64XLGX1qXkcVotp3 HtEpR3iJsR8iqhzTdz/LG0y6zjQ+aOY3nnKElzg19Pt6mfjBt5zJG9S4s+FXhF3O7geWNwhe1J5J vNstR/JCulYDVr6amTdo5IqRQ54ieHT5PU34hXXljQexxjU7tj5J3mALygOZwF9A7SyWN4jvCzk+ 3++MX7hp/h/yp/0Wv3TL2bxB9X9WzMeDfcbyBpGHKfffiafecoRfeNhlIx9v1iOi4yR5gxG8r4i3 KWydUX5hXWcRfL/UD0byBiU/SvIG24dxkrxBrOuC/ui9SfiFJ69Y1PdYoecgyRtMvqE/1FWgerH3 Q4VewPfUE90PNm8w4DzriqOHSOUYv7DyxY4CWyZ+9y1XTrkyzrHxU/09na9Pwi+MPL55Dm7xE285 kzc4+YUrana/uJzJ5yoZ+X8s3uaWs3mDdfLFAq+i9gTNG1S5gLj0TOfd5g0G+BXxDs/8HCR5g1jX DvZZot933g9OiAeE9xBxuJHuP3I/BM3j873a/I5bjtwPYeZr+w/rxd4Pus6GP1nXGfVLsbxBnPMd ebvUH0LyBmvUcU6/In2/G/yvg4fn+om4NUflCL9w19rkqAsV6fuW4H8Z51JSnKvQeSD4nwMOlFUv /Dwj/MI6AicJN7/uPMVTzuYNRvXXzfqUnd6bFv+rHfuhaL5TofuW5A1OPseifNSlsnEyfmF8X9P1 KS0bOZI3OPGVAhyosu8jeYOTz3j69em6JvzCE2/swBvpOAn+56bczFdj+iR5g4I3drUD3/FuWlj0 U31mwVcmPnrHzx9ypL6v4GrDLYx4ds3bhVzAvyM8s5qv62fdiKB8M3Hph6zPyywLWrcaPJnzXQW5 iVNa3DDOvLNYwMfZqJzJH/PAc7LmtdZQqJzJH5t4Y/GQS0zO4IawSP20e7BejFw55XQ/+BlX+SBn cMM7X610rGuqT4MbwpL1QsD6ob8TH5N84oEbIh+o6715yhncsCo+dvuTUZ/EyJVTruP7OnA1T+fP 4IY1z3h95eVHnQojd+KGyNcNEw8A3mjkjF5mHLzTOozNU30a3LD5Kaf5zM3T/gxuGNrdn8wD+O5P ueN8ycBFm/KeveNKjJzxswsv2MKPWek6s/HCsWj+Q0F9mUznz8YLB/B/RuSvVKpPGy8c4J+PsFv1 PjJyFrfwiuNF8NSov+6Us/HCglOt/XkqZ/SifswghUXffm8jZ3EuyCWHej10Hk57cOav+NvPUGl/ FjecuFpF3Fpi80BwQ/jZha/C3EdvOYsbIj8A9afxTjVyBjfswOMieDnofjC4YUTdsnj7dwsdJ+Mb VZwyd+TV0f4Ibti1v4R3Kt0PBDf0wN/zzF9h65rwjWocdVS/3dALWy+MbxT5DzNen3/fcz3TgO9r 7HxhuKEHXuzr8i4+5SxumJA3ePMlUH0+44YRfCWN92f3bZj1dtNiXxs5ixtWxX2Txnk89EfqmfaZ n5OezyVjn426pIiHVr+Up/c7ww2DxqkWxN0H2t8z32ic+b5ULww3zLsc7Y/xjSqe47X+nyt03gnf aADvpPzNg/3JcEO1r+U8knVGv4/ghiGjv/CpP4OPybthyMFfXun3nfdD+olN8f4UEZdA5SxuqHhA UX+K0/cAkTPvAKlXIHyO4Cll65rghnqvZ+W9G88kZs8T3FD5qLIE0oocOwcJbqjv1Ky4vT7LiJzF DSPimlH3ETilkTv0klGXq2gd8Tvu4pSzfoYZx4l6L+CjNnIWHwO+6dzKZ2XkLD4GvkqHOJ3O5Sxu CL68CHuCfx/hG+3YF+n1fJ4Z3BD1OgUXxT5idhbDDSt4LlEHldpLDDdE3c5QP9hZBjfMWi934mNP dojBDUfBM+DT4H2l5wvBDcUeGP5I8PN5Ok7jl8rKX+Bm3Gjh68XeD5o3WIXI8Xl92vtB604XrTvn NM+fyJl1lpricX3Gg1E5ez/kgnqRDfbgi8pZHNZVrBv1Yxbanz3nFQco6ie68XcjZ/yfDedEhj+Z ntcMN6zq15/10ak/hOGGVXESxbse3kcMNwS/YgS/d2X9PdUlHetM+WYKffczvtGmfto6+QDZOiO4 YWmKazfkOzn2fQw3TLquO/TZ2H4wuGETQgHpryFulK0XVpc0Ka7d6we7gOCGEn808DjN2wVvqJFL 5zgd6pnOPMXE1ifBDXVd9/seS2x9GtywoY5wUz7rp/cDwQ076iI61B2ndiTBDe/6cWMkj+vM3g9y roz+6srXbOSMPjUOYhBvlSW+x8gZfKx5XWdV7XlP/S8ENxQ+jxFnUHGv0HESvtGAeqbgUaLnPMMN i/JxllnnnM474Rutup86eMGpv4Dghs0DP8K5xOfd4oZaH7YjHmnGmxo5c55JfXupn4q6nXQfWdxw 3ptZ/QyF7/fzfpjnWZUL7B0XZOTs/RAx7+rf7dS/y3DDqOeEQ51Q+g4nuKHEiV9yEfY1tV8Y32jT /iLqoNL1SXDDhnHO9zR95zDc0Gv8xIxfKuw+Irih1PcdetnqCp1yNk8qg280eM2boPYL4xt9Yb0A V6PvcIsbVod1FtWPUui5a3HDHI/16dl+t7hhELkmZaR1PzB9Wr5Rr3aE1/pQdz23Q+7EDZuUZxI5 F1E/junzxA1vPlSv8Y4aNmDlTtywCS3xS/nkUAeVzcOJG65y4Bul/okTN2yoDzvwRj2va2Z6sbjh jcOCPwT5jaec0UsCD6TiLHd+B+Se8eKEupZBz+3Jn6UdLTylJ89lztAL4m3AV2nk0iGXJn9rCMDH OpU7+T9vuar5HeDVPOUM/2e6z2vU8dO8JSNXzu/T/+PUvrvzx065Y/6S8qsJDyjskEr1edh1BXm7 UsdWv0/z2I3crs9Rl1T3reYLj+3E+zvxTT1fOvJN77iSU87whjbM6I2nyl9YuRPfbAl8oxn1+Byd P8Mb2sQPMvAO4Jue9md4Q5u7+8P6jFTu1Eub+F/R+PKH7zO8oV7Pias/rW9YEp2H8/2OvL+mcTYj HkXjyE45i+NV1DOd+Eql++98v3uNx+xSzl3uscD7S6ecvjfHgwN8LIHKGb6uLvkBHvXHJ5/cKWd5 Qzt4/Rp48jvtz/KGqlyYdas714vlDW3ANx3ilxqXO/TiwGsEHrpx7lJ9WhxP/AtdygDIPGS63y2O F4ryoqrfTsIzmZzBnULv6Ff16Vl/FscrOF/Uw3nz5Rk5g1cprulnXrmn805wvOQTvhN1W9j3kfy/ iLiLyTfTaH8Wx0viV7w2nvIdenpOMP7PrHmYO0/GKXe+34E3Lfm3lX7f+X6/xgke3azx0L6x89rg eEEAf41/QZ4G1cv5fg+o8+NvXhy6HwyON/SJ/gLypNg5yHA8vTc76osWer4YHO86b73O3+T96bw/ q0/k0WZXPo3T8jJWPc/A1+XUnj/lLI6n+SdBiF/e8fpGzsZZ3TyeMg++0P7Oc34Ujtd+wWcMPMDI pVNO602MvFjw8ND9cJ7zV3+Iu9B82hkXe8qd5/zg7cH3aVyJp+enwfFG3t/kj1R8s9BxGhxP3ysV dUOe7DOD4w3cNmOcyIvkcumU6wV5yfDrP8gZvLgCR8+oK+upXs77IcK/G+Fvf7hvDY53ySG+oISV P+uQMzhe1LomwiuA+53LGb2UqnrJqNNE7XKD40XEX0cJMHncf6RuoHeIn0ivxV9g5AyO56N+38wT 7mweThzvOs8EX87vOFy6/wyOV5CXnFCHU8qwMrlk5KrKJdSzoevF4HgZ/uc0cS5P3zkk/0/r0aY7 P4CeuwTHc+D50rz06wcd53nOF/XXDLmu919k+53wf+r4xvfp/ot0vVgcL83vUx4z1A085c5zPiOv cZ5Pj3JmnZUIHkHEJdD32InjZbz7q9ZLGu8Vvq7P+yEr//yIM4iql0THed4PI19X4xk88scCO18M jpfBE5xRV3jyfJ1y5/2QxaGl9bKRp0/Xp70f4uTLS8AfqD7Pc75KwXnRC+oz03va4HjtOlcUZ0Zc nufzd57zDfXbqxie7/zUU+485xvssyKOs7c/2cgV25/iVT1/sFuT/utbbtSXqbLeYtX3Jvf3nPhf Rjx0V//lyGOg+jT4X0N9ysFfCPydnRMG/2u4p6v6pZ7WtcH/ivrLZR7g92bzYPC/ivNs5vnPeAYj Z3Au5cGq+s5xs67XKUfiPOryfTe/sJFLVm6pp3j79Y2cwf8EJxF8E/uIfp+N81BegKp2xR0nYOSM XpTPseq6vuMxTzn7fpC8gvbm56PnksH/ynVO6zgh1zNdZxb/a37Gv+g9nfk4Lc5cgAPhHdDo/jvv lY533LuOZqX9nfdKx/uoysQ9vosNb6gWohW8A7gaX5/n/XD1V1U/Hvdmo+M874cuCTMyzr7i76fc eT+0H61/02bck6P2C8H/ND9ACfckPpLq5SEOsMuylvOM7weL/6mdOxJEwLtMz0GL/wXEazTEXVB/ HcH/1N5pmk/yZE8Q/C/JumzAY2e9ciNn9Klx/g28gA/3CsH/0qzjB71ELmfP+ax1SVF3oFN/gak3 qAPT/a77lvoVDf7nkb/exfE65OQvjJx9BySsF4f1Quf9xP+mP6Tr+1Tk2DhP/K+Ku1vqgUXkh1M8 h+RlJeWTk/NvyNF70+YN3nW9EAdRKvs+mzeYDlwU/IqnnMkbVF7MWbflyU9k8wbz5ONsms9VOltn Nm8wz7otDf4C+v478b8yeQudxoE+4TkW/4vwg0ke0OO70fKG6snRtP7imL/Nnzzz+AhPjdTNmXH0 536I+HcW/yse8TY5IX+My6VTbuJ44AGp2zvgLXfif2o/DrwxrHmYp5zB/979qV4e+jP4n9oRMk58 X2Zypv7fIlc/ye16uY7rpH72Mt9/lY7T4HhdeW3DzCuo236/5Uw+nvPA1WQl3Xy4Ru7MO3PIPNV3 xKM+DY53jzNr3m7d/FJvuXTKJciVuOLhRs7oBRaG+hXP8+WWM/l4buJ/We3duvmz3nIGDxBe2j7j Gn7CZvfcciQfT+dd3je/7jwpI0fwKuXHzOA9CFSfFseTeogSr4G6V/T7CI7XVK7B38PXC8HxZt1H 5A1ufr63HMHxwvKdM7//lLM4nvJfeXmwSn90fdr6f71o3bKOfBLH5YxeJO5zhJ02nfdA9WlxvOQ0 v9HVtQ6ckbP4StJ+8zwn2LwzHk+9H0SPj+uM4Hjqz/Dgf518HkYuGTnU/0vwQze2XgiOp7wMC35E v8/ieFpPasiVT3JWnxk4F+pFcjmbj5dRBy5rXRPf2bnEcDzgQGHjnTRyFser0AvqIvJ5Jzhe1X2b Gnn/veWMXjL236xTX+n32Xd4Rp4U6neUxvYtwfHmOHMnOOVbzuhT53vWS5t5yUbOrrMeIbfyOZ5y Fscr896ceclczuIIAfiKAx7O7CWD402/ZxSCYIP/veXSKeeC5lNq/qek3TM546dVfpSZ3ypl64ic 9dPq9836gbPOiJGzekGed1ceT1/pOO07XOyCqvbxO+/TyBF9oj+Nt/GFjtPm4znMQwDva6brzOJ4 6s9Iym96vlNvOYvjadxM1Dy3M17jLWdwPKlbPORmvR527pJ8PK23G+/9EFh/BMfrqAMndvLpn3jL Wb0Any7A/6jdSnC8jjzaKn8+8L+3nF1nVfefxrUfcR63nH0fVcXxGurxeU/7szhemvy0eu56x9Yn wfE0jmXkcWo9m0jnwebjhaP+GNenxfEicMNZRzqx/UdwvFBQF6oRvOOWs/7W2d/0o0S2HwyON/gc VZ8R9Yj4OC2OV1D3qhbUF6VyFsdrUfM+e0YeLR0nqYtRNX86YD9Edr6wfLzxxV3CheU8K3Qf2fuh ZvA1I14q0nVt74eGPNqU1/rFRs7os4EXNQLv4OeEvR+UzzHffBfU3jU4HvJ8pY4R3jl0/iyOF6vW P/LIs9n8828541esyP/TfLCZV27kDI6ncRBVCoeLv5zOu8XxJu5UUY8v03mwOJ7w9gw5rOvM5t3m 4xXE/RY335ts/ggep/UYqhA8G1ztLWf0qXXZqgTSP9qRBo8bAc2KywTwxlTan63jJ3khN4/50zgt HufANzr5IOh5RvA4j5+of9Tp+ULwOI88xQo8jr6rCB4XgI915GtTe5DyeOrPjvycBzmLU1bgxcgb zGxdkzp+opdBxzr9prQ/m4/nq857d+VTf4c+1TGl94vem3weLB5XJo4AP0Oi69PicZpXMPIA9Ryk divB44RPbMhFguPdchaPm7iaanryBRk5o5cs52e74yMLPScsHpcL5Oa7n+6j85zvytsz5NpHOaMX 5buo4HuWcipEzubjuYmvTL8GnQeLx2k9xS4BDY/3EcHjetOffta3oPNg8bgeFOeadeP595F8vIy8 XZy7kY7T4nG9ad6nw3uF9sfy8Yrmw2qdZqFBYHJGLzMPU3hONT2LyVk8DvwT0y6n/gKCxw1Ht8qv 9XpOOWPPl6x2VkGeG383Eh7P0rDO5nuTzcOJx13XH+r/9YnL0H1L6vjpzvJqT9z8kaecweP03B15 Ug3+cvZ9pI7fzOdquo8e5AzudOMyDfk5ju13UsevTVxt+vXZ+iR1/Cbfveynx/6sXgpwoObrc38E j5P6DSP8RfWCuhGnnNVLxjx0rJctXy3h31lcLeo700lB7193fTUjl4wc5gHxrU/9mby6MPEx7a9u fvZbzuBqcX4f+Dz2ffSWO3G12CePLvAVR+UMrnb3V2r8oBeTH5fFErp+Ck/i6dd/y5340bRklT/m UZ8mPy7dvJNurVNo5M78uDTzPmH3VE/HaXC1NHlRW4kWV3vLnXrBOC+5CrlA5YxeypTTOhUPciY/ LtX5fcBTNxzvLWdwIMnPb0IvNeYvbH7MW47gatqv8Bb80jRVJnfcf+7Gufzkd6P6PO0sB/+lFu4Y 60z+wsoZ/Mjd5yfx191yFlebcj2R+Pm3nNVnjJADTw3Vi8XVlM9KE9wMrvaWS3ac0AvsFz5Oi6tJ PG2/4xL2PLdb7rSXPOKavQRC/7rrLBs5o5eMPCk9QY444ylHcLWJ3yJuplQuZ/RZgI+FGZ/F5Yw+ tb6hvw5uzAOXs3lLsz/U64lsnRlcbfAD636Y9coDWy8kP64GxY9iWXlxTrnzPa0AgPIeIB66Ujmj F4+8s4o6MZsf5S1n9KJ1bLzG+9/1Bk+58z3tYR8PgxX+QaqX8z3tEc+nCSjP+jzsnhF3CJ5L1HUu dF0bXM2jviTipc78h7ec1WdTPNyBX5/eKyQ/burTAUfncud7OkjC9i+J10D9Ki5n8I7oA+Tg76Fy 5zl//fuOvDPk/zm6zmwd1DbxP8Sl0/Pa4GoBecwB+UTHO/yWs3VQW8yQI7jTW87gt7CA73dqpuMk uNpL1xni/Pf4urec0afGd4T7nZrpPNj7ISPfsILHhc+7vR+Kn7y2Whe40HPQ3g9ljhd8v45+n70f NB8oiiJHf1v8xJQzuJrXug9S91PvI8fGaXC1t1yNkGPnmcHVPOIRwl1HjK5rg6t5+GuCxhmrOcLk TJ6NR/3UOHmiqJx9h8vIs8ariX+erU+DqyWtazhwvE78Nm+5ZOQSeHSxH+h6MbhaAi/45CM/8IBb 7rwfkgSCKW/vykNu5Kw+I+quwq9f6byf5/xbLwHnZ2X3LcmP88CZw8xL5v0Z/Dahv6b8Gp2P08ZP ZOBxyL/tic6fPeeFx0PwcODo7N4kuBriKqUu+q+b98fImbzW1LHOYni2Iw2udo0z6k+8U3vn/Vl9 gue5hg92q8HVIvDeeNs9D3JGnwl1iGsEDxYdp+W5dIhnmPg0tT8NrjZ4WzUPM7W1LpuRM7i2nLeC TyNuhs77ec4X4DJJiLoED6fr7DznC+JYEvC863NZf0n/9Xpvjv+UOjOIe+JyBo9Tvq4uNBTPfg2D xxVJyNG6si8dJ5t3g8cV+GfT5Md0jZ0TBo8buLbuvxkXFOn3Wf7kApxZeLdPnOstZ87B4ve6svT8 NHhcuu4/5b/usw44O5cMHpfkoNC6NitPvpEz90PxEfI6D47dYwaPu/59eGFdI56WzoO9H/KMnwC+ ucWj3HJixa3rrIpfsWOdnjxYbzmrz6rndcI7lfp7DB5XJKFR5k95Mjx9Txs8rqCOQ5aEBlnXdB4s f3LHeOEP8fS9afC4IgaZjBP56IHOn+VB7qgHrXVYnvaD5UHuqWCceg5Guj4tD7LyaY54Io0DTPT7 LA+y+BOFR+SjnIm76An1mRHPwOfP5r10Pc8k70HiWKhebFye4ADjJ3izqb/V4HEFcSH55qkp9Pts fW3B3UdcCfzC/PvOe2WJf8H+i3Q/nPfK4MfXOJbkSN78lDN43G/iZt5y6ZQr4INPkfCAvOVM3IWv ynuufsKH9XnicVIHFXzbiGen7wDCj9knrjbjhV9Mztp1ggd0zTcz/GdTzuJxyns26EqR59bYfid4 XJ/+1hiecRKCxyXkSVXkSdFzl+BxOoJB6IDzmumF4HHllGPrk+BxcY4TeAD1C1s8Tudt4DLI4wvs +wgeV8veHx0nw+OU76LCzurU32PxOLxENBFBzqXVnij4d4z3dfgVA+Jp7zqaWf9+5uOJM3yRS8oj Lf1O/CEQOVRvu+WiuFGUZyGv8we5mcfHeKIS/GDgW9P4nrz0w+SCTMQvycvS80z9E3nXi90PXeNf vNZruvM+IXe3b+v46bx7fe/c/J9GLh1ySe15P+tCIe/MyBm8atbxq+q3AT52ytk6fhn9iT/yXtdG zuB4EesM+APyx045U8cvzDyponWacE4YuV0vXeiz5GdEvmin+rR1/DLir4PyFtZIx2nr+OEGVn/D XVfPyJ15g7Uir27WrXZ0nKaO38036lFXT88lI3fqReoLipxb6/gZOaOXEuY4vcpRvZi8waJ2xCWn 9blqp+O0fg2PfLWEd2qi47T4pvgZGvIVb9zJyBm/hgffWkHdgcj7S6dcCLOuHvJeuJzxawTwOcaA vJ7A5FgdP/V/zrrxhe53Uscv6XmWgItmut9ZHT+dv4j4pULn3fK7uaj6nPhYpuO0/J81IP8IceLq JzrlSB2/qH4inLs90Hkgdfyw3xPiWwubB5Y3CF7GGcfZuJzFA+LCQ3ff00YuGbmieUsJ9V4yO19I HT/NZ46yMd443ilH6vgF9Z9NXrjM5ey9Cb+pxGXe8cKnnOX/DHPdwG/j6feROn7wJ1fU+cm8P6MX F1DnruQPemF1/GY9vr74MY2c3X8Tl3m9lviJU+6wJ/KPvugr8r3veCIjZ/Q56xumgnXNzkFWx2+O M6x1/IycXWcJcjl/kLP+Cd/hdwNvYafzx+r46Ttu5kVGqhdSxw/18RLyq+i9wur4JfXbzHM+sXuM 1vFD3gvGSc9BVscP9dU8/GCF9kfq+GW8i4FP831r8U3UR5d39DsuyMiZd7jG02bwM06eLyNn/IoJ /lbwlfRC1wup44c6Yth/eKeecqSOn9dxNtT7dPS8tnX8YpnrTM8Xau+yOn5Z56+ijgo9z1gdv6Ry BXkFns0DqeMXkA+EOtmo43fKWT+0Bx9gmXqh30d42gr8RODD5Xqxfg3ZWUXCDBa/t5Gz/G4R/Ua8 N6k+bd7grI8XkM9F97vBNyvyWsvth45sXbM6fmndhw/7j9bxQ129GT9P9cLq+GmdtAg/9IOc0Yvm wY56g2t+nJEz59nknZz8E4nKkTp+XXkLO/jrqH1G6vjpSYx6jDf+cMpZP5jmI6ihe8nlzuXM/aA4 bLl5BDv9PlbHT/O5POoRUbuc1PFTPocqjsHHe5rW8UNeHcYpf2XljD61Llu564TS89Pgmx11AMqM c/T0fmB1/ALyJoD30/c0reOneikdeCqVI3X85JxoiH+acXJGzuSFCL485Noal3DIMZwS+QFd9Znp ucTq+AXNeyl5reNn5Iw+lQ+3Ii/ospeY3UPq+AWn66VNvns6TuK/Bk8i+BzBQ2fkzP0gcV2jDpXu d8QFnXL2nG8FdfXAT8v7s3mDd726sNbxM3LGry846pADX16ieiF1/DL665/6Y3X8yhfjNDil8mYv dfyof5DV8QvKd9hRv4ParSdOGeB/Fl5N3X+J2Uu0jl+W/KOAdzj1v5A6fsqzPvKsyvO9wur4lQi5 9ny/szp+QddZnzy6Lypn9YL+OvIbH+SMXtSf0Se+yc9BUsdP922XC+WNMxs5c56JX2LkGfs1n/KU e8gb9HoAPt6bJG+wZNTjC/XZTmZ1/ALqdsKuo/cRq+PXtF4d8sc6P1/s/SA4rNTjey1xQUbO3g8R 9f8i/Cjs+0je4ADUtL+4xF0YOaMXsSNEL8j3ZeM0eYODh0fzU5vyAgTqD2F4zvAjh3DXiclMnwyn jHouZZ0/8AufctY+q8DVZh0/an9anLJLXEGXtHJ957D1aeu5lTDzgepLcQs2TlLHr8P/iXrzhb7D WR2/uY8c6vGxeSd1/BR/CFp3QNO6rByr44d56FpvvmZ2TrA6fpiHjrpzdL3YOn5+5kV25FfR7ztx yoEDKS4TZn01iuewOn7Aq1BHs+r9oEDcUrdsl1vqzuWJhyciV167XJSy9oI3gv+6+lVu4o2E/3Py aja34sVGLp1yYeb/Ze1P8xGM3JmnePcHvgTg4aecyVOseeY3qv1SNV7DyJ15iqXMfMoK/C8zOVPH r2uevvuZfsxC9WlwPA9+vgJeKtSNMHInvilxsL+U5nuxs045k6fYG/af8C7ffP5G7sTxXMQ5kVB/ U8+XU47wf3bIdfCU0vmz/J/ip5O6evHDvFv+z4rvywm4L9WLreM3eVGz2pHg7TVyJj9A4kL6zFMV +m0iZ3G8qvmpwgMv+5bLWf7PpPXAPPjkaqRyycghv6r7lX/eyJm8gp41r2fWY1e755Qj/J8SZ+zu us6d7gfC/zlxX/CANKoXm4fiYkG/qGPE5Q69ONiPd35qq1QvFsfzWsev6slznff0+xj/Z1a7QMfp Ox0n4f/00M+sZ8PkCI6Xsc7kprrjrIyc0Wfs4NUEv1Rl5xLl/5x5S+CtZ3oh/J+zflyadQDYucT4 P4Pmq2X4Fel6YXmKacn/87MuzSlncbyCOoxF616FRvXC+D9VriEuVnk5jJzVSwJeDF7+yvYf4f+8 eTyB9/N5J/yfsEMKeLfo+cJwPI176rA/kado5AifKvhN4aft9PsI/6ebOHr/oBebp1jxc/KbOjoP p383aT665Kuh7hVdn5YXziG/qiblr+N6sfxuLinOjLw6T+93xv8ZFfd1k/+My5m4WO8U33SIR6Hn GeX/nPX/NM6YnxM2zljzGMJ14PYPcgbHUwt4xC2qHVn4+rRxHrmhvqHYB5MXx8gZvMojzl/z4Gfe vJEzeHEHbl+QXxXo9xH+T/BqlukPof0R/s+ZH4f9QO8/UsevI/+oID+c2ruE/7P1WTcQ8ckvKmf1 gnp8ZdYDo3KW/zNEyE3eNKYXwv85eSfdPF/o95l3fxI7Ocu18rw+Cf+nxocneUA+7j/G/yn6SD+6 M2XZMTmDr+i76s2PGdm5xPg/neKb4BcGT7eRM/hKRB2/iPMssn3E+D+b4uF6z/94+v4jeYod3zfr rvLvs/yfUrdK4hLAn0XHafk/K/hUJ/6QuZxZZ1r/Jkug8htvPOWMn0jrw1S9v97+ayNn8wOK5iN4 3GNcL4z/E3kT0+6h65rwf7rJxwneXjpOwv+ZZ57Gp/1u6/gVxLFExCHR+4jwf+aoeLjmiU982sgd emniGBL8EHgc1yfh/wyK+ypP+8wTPuUI/6dT/rP7XKL6tPyfWk+4vXnh2PcRHG/yf973Jpcz/J9v vtG1rqWRM/pUPKD+1LmP2Pyxenxd8biA+nF8nKQen+BqRQKA5d5k+5bgeAF1ERPy7TXe7ZQj/J8R eCPq+NFzgvF/Tt672pe4ICNn4jVu/s+P/RH+T9RFbAm4PdUn4/9UfLpDL5mtT4vj5Tz9WfBD83m3 98PkgWzKX8f9WYz/0ylvqOuof0vXJ+H/7IpPz/qNjeqT8H96xdHzrOdG1wvh/3SKN8aZb8/OCYLj SXzHzad7jZN+n+X/FLxK+EbX+GsjZ/SSC+IEwCdA7SxSj0/3XYO99XDOnzie4Fs6To93MZ8/g+Nl Oce61pl4Ps9InAf4fnMDzwJ7NzL+T/z0ccVTjZzRZ8e83/yfVJ+M/7Npf5NPnK4XFueh/KaT/5PK ERxP/JiynxD3xPYDw/GA+876VY7pk/B/+qD8u8gbRD2GU+7E8QL02SeO56lfg+B4wNXK5GWstD9j n+WMe3PmWzT2fbYeXwkq52e+IbV3bX5VxfnZA/Jl6P575P/UBNNfN+/yIUfyDStwmQw+zsD0wvIN J67W0R+zl0i+4cRF2+QpZfuW8X9O3KmAx5Ota1uPr01eVKf1wPi823zDlDReWMJC3nG4p5zVS1C5 EUam87eulw+8r5p/5DQ+78RXZn4jeac6fafqOMd+CESO8egOO2LEbSDPZrOTy4PcqAuLOFWHvJey zvvbry7RJ7dcRN3xOP0pM/5F/8Eb38z79yWNsxfeWOCbei4dcvW1y634JvhfFN+EnL/HafDNGe9W EuQqlTP45uTDTZpXUGOkcgbfbNh/dz4sHaetbyj1IqS+YVjWi5Erh5z4d2ScSeMZ1C445Qi+if2X ZpwAHSfBNzVfTf0pd7yikTvz8SQOaOCbeeb7Un0SfBM4Ze6f9EnqGwL/S8D7A+3P4pt94oaqz4f1 YvFNZA5rPMuNoxu5E990uPHneV0SnXeDbzqHPMU865K+qNxhT6CO3zjP5M/i9iFyxzm48GNOPjk+ 7wTfDIpTerWvRZ1EzuCb3YHvEOus8f4svtkUB5r11SJdLwTfjIpvtg6+oEzljD5bLct3Tt6YU+60 W1FvdeCcep4BpzRyBN/UeUccJ/jyjJzFNzNwbX2/h07lGL6pepn+wU7HyfDNgu9DvhPbfxbfLFnX mZ48N1+zkbN15yLwzY54aHYOMnwzd+gTfr4XlTP6zEnnPU9/K9Mn4WFtyBfNYa33aeTMOlPeLa/5 sE5gYyJH8M2u+LTX+eP7neGbpWM/IJ6W7SNa3xA4HngI6H5n+Ca+L8MOaWwfUXxTceYyefaonMU3 JW5puF+KrrNGv4/gmwX45sSnqT4tD6vWRfdywD+eEwzfbJDDO9XTfUTwzajrOtTwYf5IfcMI/gng HfTc/VDf0Kt/AnWajJzFN4PiQM6v+IqRs/jmS9e3R50RjQM85Qi+6RTfbAH3ETvPDL45+Q6DGC6/ 7rylU47gm7B3A9YZX582/qWDT7XDD/2i+iT4ZlK5hngivs5snqLzmidc/YpvnnIM3wROCb50vj5Z fcOyy7H5Y/UNZz1F8ATT85rVN0S+fZ78S+z8JPimvPsFv01LHPUpZ/HNGFC/EXXn6LwzfLMhD1rv aU/XGeFhlRMgo86hFzcxk7M4HnBK8Jt6ej8wfLMqbxrwAE/nneGbBfX/NtzwlCP4JuoG9op4DToP BN90ilPOelLUHiQ8rB16mbxpfJwW31QesyQFMn7dfOJGzpxnPWCcQc9Pvh9IfUP026Yfmu1bhm8i TzgiL5LaZyRPsepPvJhnfV8jR/BNxafD5JGn4yT4ZldcNAMvpucSxTc1f3rmv/P+zvshSWGaO9/+ 5mcwcgbfzMhnTl7zRfm+Jfgm+oN/1xcuZ/FNp3mfGfmNge5bi2/Ouoiz7iOfP4tvqn1VMY9C18Dk LL6ZFO/wE7dncqy+4Xhn9stcGiNRWjImR+obos7d9HtzOZt3jbqPftYJfVE5c55F8OWFiXMxfZL6 hj117EOdB/qOI/jmrKsnebF3/tEpR/DNAPwWvKj0nCD4ptYjrWov3XE6Rs7gm3e9QfAuZypH8M2s 39eQP837s+d8Az7dtB5Rp/YuwTeHQ2Lgm0n9UsA3jZy5N9VPULX+ipZhYXIW3+yax446fp7PA8E3 A3A18IA0dl4zfBP4X558F1SfFt/MWfHUiHcHPZdIfUPlqxzEa/mT3DO+CbyR74fznG/K6y3jXONf TrnznL/WiddzKaldDhzdyBl8U3lDqhxM73ipU87mKaLuXLnjaek8kPqGQfHNEsMHvRB8E/m+Hu/w RM9di29qPnNDHOGsw3HKkTzFpPmwETg6tSdYfUOH/OlGcIQpR/BNzY/rN4+LY+uM4pt9+fnwrqL4 Js6XtNY3POUsLjPrKSa1szxdnxbfFD+38Kni3dipHME3X1hn6lfkflqCb4JXOkx8LLD1yfBN9etL /RTxRzJ9WnwTvH5u8t2Dl/GQI/hmmfmbZc1bOuUsjqe4qDqkRJ9s/gi+Oftrs64e6+/EN4scLxgn 8o/Y+WLxTYf56xX4NO2P4JtFceY5f53iD8/4Zp9+6Lyul4mLWjwgIE+x3vWyVrk85Swe5ycumoDL BCpn8w0nXgVcZnuPveVsviHmoSA/bltnt5zF47Q+kBPg3+BHb7kTjyt6s418w7rkG55yFo+b/MIp AI8rVM7gceDB0jwNL+52JmfzDQv2g/rZ24ar3XKGN9RBUz85Ao/rVM7gcQ44VwJ/K9cnweNmfx48 rI3KGTyuTVyN4YZvOasX5DcCp6yezl8+10ufvKhZeQtLpPNn8Tipx9B/4sw7q1SO4HE6Xolnft5/ Fo/rXv3Xk7ew0f1A8Lig/vmKdzjXC8HjiuYtFfgx+X4geFwOb/3c+Q9GzuKbTvE/wQFvPqRTztZF nN/XoBdH17XF41JRf7LTPG9xlxM5g5OE4f8a/LaKb4ZCz0GCx+VZ/0/tEEf3A8HjkF+VgG9W9n0k 3zAiD6xMu5WNk+Jxmsc366tRvRA8LgLv0LpEM8/NyFk8zs98Q7VbG/0+m2+YZt3A+lHO4nFp4kB4 p7L1afC4AP4sJ4EQBl95yxE8Tsc543sqW9cMj2ta3zAjvpzPH8s3BI6OPOFGv4/gcbM/4Ah0/7F8 Q49zFHZrY+c1weN03rxcRPI+4nI23xA4XknQJ9tHFI/DeTbrItL+rJ925tFq3qikPzE5i8c1xdUQ x+kLHSfJNyyKk2jd1pn/Z+SMv1XytIUPWfH+zPsz/laHuogdeUt8nASPS8q7rHUVJfyUyVm9VNXn rGNU6bo2eJzGAVYJK7F+xbccweM8+kO9XXZvEjxOeaXjpVfUQeVyFo+DXEVeD7V7GB4XgeMBH6P3 NMXjkDeIvEiN9z7kWL5hnfXOwvM4GR5X9Psy/MmBnbsEj1Pegwi/1sP3sXzDHiG31qEycsbfKvb4 6Ffv20D3A+ENlbjkLGEisj43f/JbzuJxwMfSrM9Fx2nxuDDruQF/p+cLzTdEHSrkW1D7jOJxWp9r 1nOLdP6snzaAPxk8pT7S/li+IfSCOAH+fQSPQ90kwRtvHlYjZ/GjPPMbX3qPUTmCx0XUy0rgU2Xn EsPj6uRBRhwS/T7r7wE/kQdPDX/nEDxO+ecz+KwlbY3JWTwuAeeCHzrwcRI8Dvy7uX7Y7/Z+mPWk Zt0k+u5neFxFfmNrFo+75c5zvl3fB7xRz/ng6f6zeFwpyr8rfP5erlEm94DHFSHIMfEatxzD49QP XWHPJ6pPi8dJHMOQax/kGG+o+gfL5HOk7weWbwje1wbeGDoPJN9QeIIGHgS/N7XPCB6Xwf8ZZv1w KmfzDYPYc0UIzX7deWBGzuJxTvGx8b8e3wEMj5v8prOeIu2P5BvWgvlrn/qzeFzUee8BeqFyLN8Q eYOhfhgnyTcskz9Z9ZLpvBu/6cyzUT7kO+/FyFk8DjyzLXsbX/6Ws7iTnNMF8UhCE87kLB5XFVcL k3+JjtPicVqf6ZJrBOd6y1mcpOm+CLCX6H3E8DjkZUXYkdQuZ3hcmnmDeB+x+4HlGwKPSw51AJi9 y/A45EUm5IdzvVjeUK0TOfYDwVduOYvHVb03hV/veZ1ZPE55X0fAP8HV3nIWj5N4lC5ExgbnestZ PA7rpc97mu5bgseFhv5WHnkjZ/TZHOTcB7uA4HFal/Kdp7jlI7zlCB6n+Gb38CuydU3wuBb1/uuK 4wX6DqB43Etw3Ip3Dn0Xk3xDX/f1Qt+pBI8Dr5/G5z35z0h9Q+G96/KZmq9G5SweF4E/BM3jq5mt T5JvGCfOBb8+tUMIHpchl3pY8g1POYs75TT7e2l/7H5geNyU893m2dxyJB8POBDy+yu1zxgeB7xK 6scr/aSVs3ic4IsDj5t8vxQPIHhcQv5YUL68utlnM4+P5OOJHzOO+vbdnvP1QS4kxfuvnw54uL43 x4Dr9RTNOZfonQ/pb/7wv+nXn//yT3/62z/+5d/88b//S/j5y7/85V+jD3f9ulbW+HmdR279Of7m erPkP/gUr7dkLb6UP1wKueyGP7zcv8Zgzl///Oe//PGfXq8//Okf/vhfPv273/39/6G//uY//N2f //nv//Ln17//h3/6dy+shr/549//1//8J/9Lflwb+u//7k9efr/++7/98V/+49/+l0tlv/4ki/xP f/c/5Oc//P1/mn/+t+O//0ZjP97Jqro5ji2if47DwBgX5nD4o9DNSzbKd20M4yY5LeKVilQ9FbC9 /BVtDIM/dmEAH20kFFJUA+u7NuRZEIuCQGEmUQgX07dtBP27poWsBoE+Lqj+vT6CGAmxKzldSkpG 6iSG79s24HJrGogVghpKTgMvvmxDzYOIoo1xOPcR/Pm9Tpv+3ShYoQnYDQla4fs2upjtUaN+rsfU z00yUL9vQ0zAa51K4F5K9/pQw++hDU1qOdb6CMLzstY9Hou4FHgbUnCBtDG+Id2E27gAaRu2nO1Y p4OcfwRvh6hkFEOnz2vsbCPMedGn6XjQ6Dja9+PAOm36CI71LiL0Ye+fbWCd9p/U1LAekSXvAOOv 2tB1Gqq8Un6F8S26xuLzfjnbuNep7zqOikJm9Xkc/XxOzrkV0CaFn0lW7Z512s+nyWxDAOVxnmYY SHS/wJFxwppNv0WcptfeDxoc0jpd67wN+bYQ1aEZojBB/roJVr5rQ77tkpVnaZikhpN89qs2sE5H YL0GwLZZaDN834as0/ENUsQmwKkxQZyv2sA6rZBtShT9180L1uko+qrjyHFNnvmqDTxp+vVy0oIS zSOw/vtxtKlTaWM4WT2Cwr8fh5rmAUQjwUsFCDmD2nMb536Z55jsxaGPUBZnGG/DhHygjcHoIQUv kKDA7wa94Y/nyL1fhNwuoFi4U1KTL9t4r9MOnWpAZNcHyndt6Dq9Hovjnht3tgbPt07PMdrGe53m iPMdBQSf98vZBtap+4liBwUlZxrj+L6NZY3BQYOAo/B8fpzPdcytEy+S7F8tatHq81o/n4z33Ioj ZBAqwbbkbZTl97ONpvMynH6aVCQkE1+2cd+3LSth1V1Aja4P3oY6jyZpVZMokHdQ41dt3HZhAjGY ryvx7ldtwG3UbpK3BKer+74NrI9LtqrDMCCR0NM9J9Lp9TQvcI6GtBZV+qqNe16kgN5Yp7jn+HnK 23jPi671GfzCbVzaxjIvcIAjYcPTvU/buOclZziZEXTgntfH2cY9LxEJJ/POpjYMrKjjTNb/e+3X LkWk8gzy5mcy/vUB5bzbkLMoX/cczo8PbXA7eQQ3TzsoPN9RD21o/0ELKI+CTPiWxPY+b+P9Jqyw YaJ/trUf2tC7YRQWraqPSbD3V4xDdHx9gxQXDdcbCKScme2Xhzb0/yYF6MJgnMKd/fq+DXH6hqpk CtfPhKS79v3cvt+3MyGnrIWqv2xDbNxRtFHHM4Nt6JnM27jfHvJWvPTRURianh+8jfee87o+asfb 48O3HFDIPS+SiDH2XEWBsue5PcNr7jbkTA5Zi+N9nlt+Z8t9q3uu6zhAxPNVG7ctpUkG7QZlP+jU tDH3ixBwh5H5g3fl894/27htqVpQVBLgG31X8jawPuCPCkUDMZ0G0n/Zxm1L6RuoSzT7L60NZtvQ UXMbd5yBeO+jUKKntgNv4z7HIpLZxB66yWu/a0PnZRCo6NmMO9sHplPexj0v2WmyGoq5dcd0ytvA vIwA4Pi2MW+A9Ks27nkpAD3b9Aexc12lIWP3ixYwaXdBH3pH8TZuGyY5JJdqUB2S0L9rY9owdRKc ImCYrnXexmLDIBkX5ALUDuJtwIbpKNDQ3gWAntfY2cb7PI0K0nuQ39L1kZbfmW0Z1U6uKIDa2Prg bQRoVoPBBvlvqM827kMbc16U4KPPhB1+V/I27nkJIIGuEaQrbJ3yNm7bUgNuBwEu7uzX123c8xIK iiV7JOmz9THBaebbGrocPouxfxU4bp3pg7dxn2MeRWNHHK3sW7Y+HtrQcwwExAEFa53kBX/bxj0v LiI5+JM/mbdx3y9CJHfZMjPB332v0/sc603vl+A+nGPaxhnyc9tBEugQuhIKOSX2fWrjCB9BG+M9 p7ot8EtRDEf/taFsnfecEHGKz0/tU/re523c62MGl0jQ1J0M/V0b6hsP8I/1OxCqP+v0bONeH0ra OLLgsPef18fZhs7TWBfjTJaf+a/9Fp2n6HTfhv4OSmd3A2/jxpLEnx36JNxz9Dx9aEPC02LU4ihX WwHn6V8xt1l80aONl36TJgTMALWv2rjPsdxnMe7623k5Quuw1rsWVov+ti0p5ok2Kn17NA0qGjid 7tvW2ThgVVLf1mXzix02bP8AO/n7Nm77w8NeDwhGpnbhQxt6nl7jqBpwkUAc8leM494vET4Uj31L fSi8Deg0aaDd+Am8gb4beBtv35aDX8qtJG60jQff5yDSHD/9JBh1dH3wNt7vqIRzpHx4Rz20cdvr Tv386q+7xsHuW97G216Hn06SZJ/uF97Gba9LYvXQxyzQ8rzGHt9RGrzedX6ccGzYNtoqY+3CjAIQ YUu0+aqNe7/0Pn30sHHZWfjQxrQLtZBEQyLAgy+Yt3Hvl+kvDBgHjRHgbbztQrQVEbj7V4zjba8D j/IIMvfr3g+b9sLjvKBgepgJXuXrNm57Xde6m8mB+7z8po3bXm86tzNQdMMaP7fxvvfhg01IRgj5 6zbueWlzjue8+K/buDFxB3KlSYq2vQnTPgN0XsQHrOf6JMQvr6/buPdLcMBfkIy83S+/aWP6g0au 5BhHySAMKl+38fY5dh2HJBWdeMPnNm57XQgXxzj8WnD2qzbe9gfulzjft7LnlM3kt/FS4885S4DD rwyMz88CcF+2Mc7z3NTvkBPOgBlc+WUbI+4jD502aaOXv7oNjcPIWYR+ZYckyEkC9l0b4ufP8Xo/ dfkZJqFw+NAGiw/Kw2bI8rPgHdU/zQuLD7pkJSEzR6kAKnv/eRw8DiVHLXqR/a1T9aHwNmgcSvZ6 9oxvQSxLojr9EIcy4j+S+mAj9OH+ijY0DiVJhLf4T5GgqjET37XRYdN17L0O8tHw/TjUlhj+yrEu gj6gfmn41rdtIGbCSwCd7P0GfN8/t8FjJkZBQ69+7e2NzNvgMRNDp4rPVQfSQ7rnPmHzSe+3MBKh NGai0XX6AZsf60OwgqJFCZ1sQdvGR6wRb/Q4Cino+sjsWz5ijV2qMo131CSnDc/jeMAJR+XBDH8/ iNeYPj7ic1WLtI1vgl9K43K+a2N+ixBFjvdtAAFj+b4NwZZGvOe4I6ObyZdIZv2qDcWWrjZmWzN+ LHyYF4ppRackTON9W1GcLz228YBpdS3wFpUR5vEc++TbioM0NUgcap8k2ew8/eTbGnHSw5aKXRMj b2JF2gb35cSsPosY7zg2um8/+nKKrovrZ4OPnp7JH305wF5jhX14TRObl0++nDR841XaSnh7ZHaO ffTldPVnx+HXhp3M1vonP0ys6p9LmjH66yaI421QP0xsmiQyxoEY1u0snCRz8BbI/UFwoFRATImE Np++buO2k0Ufw16Gbbnt29+0Md8vvarPsfYVO/mqjTumNyIepqO4or6BvmrjjkFTopYRm4eYzfh1 G/f7JTjgt0i+2+Y27G28HuZFifEHUeXrZWztz23c70oH7DX6tUjzd23M2MDo9VuoTj+38Y619vrT gzxss3E/t3HPiybadmGMeL/Vv2rjPS8ReEOv1k4us41PuRpRCzvHQfwE4u3+dRu3n1+SYweJaVL/ aWvftyHzkvGeu95REW/C+v236LxIfJL+rBpvCXzuqzZw6wRNvE66QN9xKF+1cc9LcmrjBmB829zu bTzEXFXFssK4X+BTep6Xx9yEguKeNWJ9pO/b0HmpSgg33mR9TWj9qg3Mi0MeUL/f6tu9/7kN3A1d bdw48Llkz7HPbbz3C+IuiuYUdV1jAbKzjd+cY4g/netUczW+auPtt5znOvI98l/RxjzHPLDGllc/ 3VdtvO8X4LcOReH1HPuqjfc5VnUc855TTOurNt7+MeSM+LK+98Oitfeo6b0veLaOI02fY/y6jXte Ziyt0gfMJPPv2pjzogR6XUCkd77HV20seCXikzP2fvu6jXteCmJ7ZuG4v+Jbbv9YzyAHnyRh69ym vY1jbu950UI1HbFo07b8qo17XgSzkLg+Mi+/aWPOixC2jvG49S32VRv3flFyBcSynHvucxv3vEgB yLFvZj5Q/rqN935JE7PAGeRJGx/jP4rGsQ2fQcqLrf1VG/e97xDX5xEPk9j6+BT/Md4NUfO1WlRM S+2Pr9q494sHqURCLs+29z+3cb9f0sBvR14hfGyVrY+P8R9NWNuVPL4vPgPaxkPcRdVCnWFUKPHP 6+Nj3EVH0bMmThyxtZ/n5SHuYuTgFdHLLKxC9+3HuItLD/Mn8pL689w+vpEHZ5fMz9y334/jnheJ lRx6iWtRE7RxkGNiNsx+kdyE4etr0Gn/uo33vKB4xbQd4l/RxoyXEt986Oq/vN8NX7WxxBcCBwKG 49rXbdxxF+LDCf3GgbYz6HMbS3whims45ANJG3HR2t3Gg5084rR1Xjr86xrX91Ub9zmWETdeEAfb vx8H9otTwsKhl3lnx6/beO8XkPj4hJyR79vAfnE/0183CymF7/Xxnpcy79uynIW0jQe/dta3+ni/ 5DUm76s2MC9V8ZdxjqU1J/G7Nu79Mu6EMT+IQ9F77qs23vHrEqfUb994fF4fD3EXI84xaQxY/qvH 8Y5fD4qJB+TOqu8CbRzF4rmdPDCT10vz+ECcXb5u4z7HInKJM/zaiiN/18aMU5JzdMQXotDpXzGO +xxriN3I8Cn579u445TE7hjjgG9LiQC/auPeLzP3LZc1XwxtlL2N18O81Blv6ddCs1+18X6/AM/O s7hO+r4NnZesvr6R44S5bf7rNt7vF5zrua/vl6/awLxk+HLifTds++VzG+97P8xxxGVe1Gg4MT4+ L9c4kuZ6ZcTCKf7yVRtv/1jR935GrKTeDd+1MedF/JYDHwsrhvNVG+97H++5vOHqX7Vxz4vmVisz 7Bsn/KqNd1wf8htyhV2Yn9t4wsTlHTfsMiXeRczmV23c94vgx/KOwv3Sv29jnmOSyzPuu7zmi33V xjuuD36HNnPvv2/jHW+Z1Q6ad1T9sD6e4tcL8l9KXUkuaRsP+VGjAK5i4g3r9MNaf+YACA32R/hr x3FzVUicg2DBGiNQn9f6MwcAsIKIYohq437Vxs1VIbFOYxwFBTye1/pzfhTssY5x0PXxmzycCN6N yUGk9+1XbQRoVt9xNwnn9G1918ad411nHg7e2Wxuf5eHg2/qfiWp/aqNd+69vMG6MDs+7lvexn2O Bdz7IG3cdXr42Oi8DL9lBS4W4Q9qX7dx3y+a49Xu4u/+r2jj5szo8BdOImz/dRv3vFScHxXx/L1/ 3cbtH8vIj0IB9b9GH8t7H3nAiNuSv55tHLGB3E4u+lYXO0Ttj5i/buO2x/zku5icCOn7Nma85eDU F39d0G9x37ex5HjDLnyhjf51G+94S4dxTPw2fN3GO95yFsWc7/11v5Stx0c/jMQZDHsINu52Fn5u 4+2H8Toe5aqa75fv2tD3flEcaMSB4PxQvq2v2lj8MDhHKnwo338L3vtFOX+un27GW6av21jiYAP0 scbA50Vrr9/4xy67Q/KSxrtuzdH8qo37HJt5wLGvuPp3bdz5hGM+BpcZYr71fvmqjff9Ak6E5JC7 8v043v6xOMeBWFr/dRvv+wXkxRE+A819QxuHj+3xHPPgmZhxsPXrNow/eeYE6Dn2XRu3HybB/wEO EY0R+KqNZb+oHaQxHBN7/aqN97wMO2jEOWIc/ftvee+XiHMdmNa2To+3aaHzki4bpuq7EkT7mz4+ t/G+X/Jcr3jv/xVt3O+XovH8eZ5j6es2lnwxXaezuIH7fhxLvpj+zOAe7PnrNt7vypsLKdszaG/j wW952etN8/gyYmpK/LqN+/3SIt5z4IdJ34/j/X4ZtuXwT8GvrbjYV22835UNeGUGLvY8Lw9+y6jx lrJO8xJv+VUby7sSeGVb3y8Fo93n9vU0L8IPE++C08qJ8FUb9/3Sph9m8ly179uY89LwM8FOVp/j V2287TG8QfLMO/leH/e8aD5yfONA9es23n7LhHEgZkJtS7Qxbbrf8KEo16+/409T+7qNe16UHP56 i2F9aDzMd23M/ErJA77GURBPl77/FsQpeeVhHXyKMSw44VdtvPlQZDyXPuZd+b0+7v2S2+RSC0uu Bm2jHXP75mK8MU+9K7c997mN+34JGUU65v3Sv2/j5kOJiO1J67vyqzbe90sD1x5sfv+9Pm4+FOFQ G/ooa4zzV2287xdwmdy5TexbPr5fMvgM8mW3g4uAfcvH98vEjxv8MfO+/a6N+X7xQuh/nevguKNz +5v3S8B5GoB7vL7/lvv9ErLG0Tv41x2bl9+8XwLet9MO2sZxvIF+aycjDja0r9tY3pVqnwZPzqDf tDHnZZDaCVd3zVYfn9uw/EEbv+VXbdzzUvG+9fGvbuO9X3DP3ft2PYPuGdAo2mNu3/MS8d7HuzLk r9t4+8cS+AwQy5K+HwfiYJPGKObwLmDZvm7j7R+L2C8zFv/7Nu44JV/me/9lz/XPbbznBTiQb6TI 5Xyb/o7LFdwuMa3r9Ks27v0ivMlyR4Er6/tx4H5pKPQ5YiXXmLyv2njvl1lsa8ZuhK/buP3JGb7g BN6vrcD35zbecRfTL4W44A9tPPr5/eRyBe95f9Yp9/OvcSjgYVW78Ls25rwkcHWWsNY8+KqN9/1S sV/gg/0rxnHPSwDPRJx8KN/rY7lf9Fz34FLbihfNs/DjORY1Lki405En3r5u432OYc9Nmz+U79vQ +yUhzzNLZfC33/KrNgz3cZh4dvq6jdsP05ryOs17fyvs9LmN9znm5j23+gvRxnEWPt37ksMz7pfX y55Bn9t43/vTDkIbqX3fxrxfZM9d90uf79v4dRuLnx/rNaa/to33/eL1fpm2ZfheH4udDDto+mFm 0ace+vXBNftYrglv/9uKPi2/pOLPP/7P/431n8I1T7P+U44uZa3/FP5v/af/Fb9I/ad//J+k/tPr /3Hlp7DvnuED7hpb5Mr6rv2ttNwkYLMN7c5QL99JtxlPpDWJvPpc2sbB8iSNWzXjNX+dEqksHr3f SCvPxsjP88pFEevva0y9pd/VUJS5IZYPTI2cW2Tw51T1uzvkklDuKs4qItE++nOWvaSMZDxmqUiK lBRrBOdm5X1TBo8uFeLH/1cWDifBsV9Iy79ukl75kkL1Vfy45WPdlft2EhykKdvykMbIS6VrjXJ+ aE1uLVqoeXeFcjhyto+iLDS/lJhKvvtDhYPzThzhnfr9wlF2SWfK985ZQoqQgg3dJ4xcgkSsNOUH KUL/IMWGxba4i0n+RnpiT5faxqmQrqlqKl2JNOxtcrYAX3IuLbbRKU2ZPLxXtodrnweN3q60WhCP yVc6A9GazPvX0lipVb3SXtkAnO6a30rrl3Qx90W6aPxZpXyynPXDO43Svta5Vw9woyxsnO/j2pka N3/Xvirhm77BuHGNGJmlwuTk5EH5e2mcyKPQptbLc8pFU3ldA8oQcn23ZhrG6yZStnnKYGcwANlz 1yKR2OVxIOsObZSz9pTW00ETncfMeURR1c6lHRv5dX8Nv7+cirhL2HdzRpKxvr2iB1GjJgtnp6Zc JKN4uYzEK//fGDnb3ybTS3eoV0/jYFXCDZw/sRbb0yHpd0/OH3oTcQaUa7V4ZJjCS1ArW+ec+8Qn 1bXEvenp8IGTl+hcSvn6oix0d5bc76QTsCqNpxwcQ6hlxO5QznRy9SkVB99Vriqt2sM5Tjxin/1t t/Aaapzd5JIWZNsXZVZ++m6OS5dZCHnUCROt5fqBG9bcgsNpOVqRLJyxzgvTmsGScAP7WfS5qtYy vf05O9UIBnzpyDt0HpjOOQfbuL+kHke/zFvd37RmA2dfG97jwWh32chey07v1W/uqLVz5DjXhtta tJZRRDox6cdT0evMRdz+TTPj/T7yh3qw74LLFbiZ1pj5rXTWrM3o1Xtfw4pS/1a6NeRaKj+01pSU J8LvpVFlNKoXdTBXzdLwH1gED+v++m6Ju5TvhvSLSjPr/pLOw3Mag5i3Q7pzaVpT9NJ5kvmUgj7v nKRTmlr3XUhXZZ0jar1+Jw3rXmIRZH9HLcz9gQfutJm06Kae6xrpUTL9bmqf60PyXVTcH1xFn+3z KiTicjoktRULZ+OjFrbSmMt3J+Xvbo5KUwt7JMLDCgioEvyV9G07KDY+zvOorxq2Qx9s5CCGitwK 6bVYPac0tXKHxSV5XiPPCrZD/UIaY/HImktSGlVOJjbfD1ZuQN9VceRxIrOV+mDl5uufI8oK313Y Sn2wcqPiziOXQK0evlIf7NRw7e8kI3fqza+Rae3BVrykpdUqJEeP0g+2Ylc0VdiFNOOInmsPtuKI P9B6o0H3dy+s7wd7rQlcoBmoyMx5Zr0z9lqTCVZuFHBdshl7sNe6Rj0M5oyGSmXPTHenvTbwjqDc UA7ccvWbkasNJYxSs/KsWlz0Hnuw17pyz8ubaM01OaW5vdbV1zGkW3qeMW6vVXHp6bmmdkuhI+c2 U5fkR7W49F3S1LdnpJnNNO4x1Jnoirt7epc8VE4uUsphtDKjXDa7xc9//WAzjRAq+X6Pl8XGaRh+ Jz0i4YbFBYamurFu3qgQ9VJ5pzVKrxPKKadrjZ5Ic4/JsJWEFTJrNs+Nzh/SD6851AYavF1+zY0K X2pN7q8iH6DfvTJD/E5rt53qoHO1FSF9xALat4H4tqpWApC3wTry20bmnuCuub5jp4JjLDHulef5 TjpyOe+dPCit9IPPo2lsfRiW5ktf0IlI8x3apKCc3ApRmWdKW6VnJPjzOvc68hiIzu8T+LVLK2JY oOuilSN/3dV0DzaAx3UuvHLyitf3d2DcCtzf0iS4UT1len93Kv3gd4jAFuv0I1ddLUe+/LPW9Pul qrNo7bVIl99KY6XK/71PB+S6PHmC33sMOk91nbHfSM9dItb88N0HfQumzvrmHtEuoKrMXJu2w4tI P94lffo0NTa+OJZXx637EVRSpJWudvqM9Duln7QW4TmY3rm85gX+dn/f8+2J9G/nO+E2mH7kLed9 Sp9eC91zSdlChrTHavFrZsPvv9sfq2XNA/jt6SDsWmatHVHzfMZG2K0iHviyyel7SD/5UxvehH1a 9zSj49nXg/cJfJq5rTGu8x57Wud1Wj2wz1tbIyB/fzrU43Rg8bXPqwU6L3Gdsd9I3ziRV60V9J06 i4flEUKDfAgesqb2WlZP0SH9eANnfHfTPVbKKv201rTvpOz317wn2EwlrxGSv91jZdpr2/6GdP2d dIqYMdzfmUVXhUNrCVprskK7IriCeLyI9LN/TfsOfUMdDumnda726VjnAT7NNT7t91rDyVQj+e7f aq1B52E7HcZWja7WFqNrObiY/38hPub/7b/+x9/+4792+M/n+J+Yio8F8T/FhyzxP9ez8f/G//yv +LXH/+hq+E34z/Xf//E/6r/8j2PdLH/8z3/3p7/7p//6twagcPMYwh14HWsAgPDHLmR4y69xB122 Jm8o+FRTi1LjNyJf6m5IzsGjoWzDDsiItPjIuyGJY9wbIvELbETJbw21aBp6j8hvDR0j6nVtyLdq GkrW30tGlOqmbDGxtobi9Q8MXG5GlMV/uY6opqOh4ejjDa0jypKsso7ITP+wCnihsXVESVCataHl S6Gjy66YL9PnEY3U172hTUXS0IsA82REbVGKNGR0dNmLvKF1RAl+r6Whc0EO9oPZUNwa2keU067s YnR0WVHzHfo8oviT/fZpcd9sso7qQznnYx0te0JeiObTitVRMiPKm3bFdeg/NGQM2UVHana+R+TO vTZ8Apwh59hredv9vp8jYnstEx3Jg2BpqJ3KZjrKTEd+P9iIst/nUd4aOnS0bxFfrI78/dZ6HlEU uuGtIbuO7JldmI7c0dA366gwHbn0fUNla2jXUYjbUes3Fcleu6zn+cJ4HlH8Sfu9ZpXN1lElIyrL wrne1SWadZTsTVvNiBLiRe6GcjqPkfFqng3VraFTR3tD7dwig6J3vieeRzTWUdoayuZgc/bT7kfR so7isgIHstrPC3K8znhD+zpK7pj+fDZ0zYYJ4CAjSnlf2WYdDQox3tA5ou3T7F5bP81vDa0jKgBK lxGdV/aAEAzOwkZ0bJFkjpEx/aeh5ayOYt1PyGAaIsrWhvYRxbaf2cGs7G6tETuism0uaeg8RgZ8 fFojdET7gvTu04juhjzR0XGvRbOymz0htaFjRHk7/F0zK3sZUdwaOnSUw97QOWv1MgZPa4SPqOwN fbPX/HSorDrK6f/bhs4R5e8bSltDu46WF4Q2ZNaRy4RH8RxRlafGx4ZGkK/5tEh0VA+LzRhabEFG oqPdPLZbZNVR3ho6dJTC3tB5sNVr05zWiB1RuS6yfa9FsyCZjqY7c9PR/mmb4f+419L/Qx2VraFD R+FoyOooGWvEjqhslz0/2JiO8jmiJJUdtobMme3I4Z/PESUpNbM2ZJ7rg+f3tEbsiMY6yp8bkr12 WCN2RIMU7xjRV+touknvEY3IpEVHw68e/N7QgH4fsqu3T9sbChLCu+vIW/somvOoSUzFu6EEQoR1 RMs6MrGhS0N+ffcL2W3eGxoVjB4De++Gxre817KyxpS9oRE88sCgtTY0QJ+32CiVE45Pq5UsyAle vRuqq8km2VLbVTun35zZZ0Oo0nP/sf60djZEHAg3KPVuKEkpyfnHFOXFsDU0/P6chX9zRGUNF5gN +Z+YjhG1bFf2DaK/G2oaJ4o/lsHz0faGZERHDINtKBepCD//WPsld6zs6u06usM47oZ6kGDh+Ucv 6St1b2iM6IzBMQ35WiWJ+f7jJE68/48ExTyGAi1bJITlXrsWegvHrJXkH2Jr9ru/rF6/0ZA7ld37 c2jTch6VmreG8naNSHxXfGjoGNHqPxp7uLWzIRvCYo+RLlkU74auLRLC3tAgm+e8ueuIupBOrA3l duz+8a0PhcO2WettbaigHNQ2IhvTxEbkVk/EaMjca9EGjdCDbTmkx6lSy6FsWdkHOl3M3e/jz/Zp I0XrOLNHBfCHohH7mZ1d3xrK5zoaW4Q2tI0oyPRuDZ0XZLReP5AeLA2N9KP3Y0R4ys+9NuKDHnh+ 108bB9v7qB1Evelc2T08NLR92ijn1deG3LlpR/7oA5PqfmaX93yPM3t3RI4ze7jqj4AvlMZZnSzD V/9uKPvjwSYjsrEh9DoqdRlRBkPU0lC+lMYb2mYtS/nrtaF8LMg8rqPDGuG3yNtq+FWdRhOsDY2k Nk4nvBns5XpGvWetjgVprqP4xB+1zlrdtkgZRRmPm3Y0zBvaZu062fr7giyj2sR5Qtb0xDiybdoM 9l7946hP7fzW0ODp4xRM28q+Pibfu+v6Y0XMwv1/hAHggWtjPfxHLPb707xPu+03lD1eR7ShdURN S7O9G/Kabb001Bb3oYmhWQ//VbXX8eTDMWs1podgu/0JkZYzWrJpyjlr+UP82Xplb7ZH+Nm22n1l 0xDb/crOq/d4NHRateuVbSJHlitbeYPeDdVibpF8r6NPI1KSmrWhc4vkt8VmolEWHfW+v46CsUby e0E+mzXlZ+t/NHTeawM3m/fap3XkloUsn3a+jkp8u332gLLD0Ar7p1V/Wv7D9Mu/01HbnSzj0/p5 ZV9DnjoywVrrU9TtI4rnMysvBvsd+2xcrHW9+nVEp+k3kg1MaKpxsV7m+grTj2zo06wZZ++519iI Vp2MhtqpbHnTHnuNjagcys5nQyN16dxrXEe7sou5RXoye42OqKwLsmjA3K4ju9fsiNqPWw9WGdFx QZaYzF5jI4qb5V+E3XkfUfJmrzEdKQ/He0ThvLIHh8K51+g62qa/CNfaMaJq9hrTUdkefhmV5JeG BKg79hr7tLZN/2CgPld2ynavGYO9aSbK3VA8QhCGjmqze425D7d7bWQmnzq6zB6z18yI6hYnNEZU jOkXq91rZkR1885oQ+YFWe1eIzqq9RhROU/IFOxeIyPa+h+zdr5F0vUUMHuNjCjX/dPMdTQ6NHuN jGiL0pB8y8M8HjTgZq+REcWwTn/cgi10RMv0x62h4zxy+xYxz6xE7jU2Il/3Ebl8jijYe40tSL/t /iTW8KEja0OKOs4TcnOyjPRzYx9Fu9faqaMmeRJrQ+18Zo1ezV4zI+qoljEbCspwYho695oZ0dhr x/T30xqJxe41pqOetoZMJMtwMJm9ZkbUpQbP/mnnw6+Qe42OaP80n05PhC92r5FZi2ltaDjrTrMm k71GRhTKbrBnYx+Vl91rREfe7wuyGRdraXavkXVU2mGNGIClkHuNNJTcbh9VdxxsY4SPDBXvN60D LQP+OFh4Tk9EswlK1lnXkJwyG8ogc1sbcs3sNebQXGdbkrTPF+TqPjRJMNuntbw21I2HvXizRdin nS7WejoQBm/wuUXYp/U12GvgLQY78vY6YiMK24IcwM35aeMWObYIG1HZNu1unELZ1vRjvtotRmt4 j01sTbSmHx3R4fTdMegZ7XNsEeaG3uIhR0PtNGucjUCI5Lke23r4X/dcPd+0yT6zonmKjnNj9daU n+3sv73H5xYxI/KTkQR/PINGxaNFXPVmRHvEiXxaOBuK9pnFdJS2C7KBSnxtKES716yOwo/PaW2o e2ZDnnuNzdpyjsnuN2HVwdu9xmZt+7S++ZNet/vw3GtkRL7vmzb1U9m52r1G15HfAV/zXhvP9XOv 2XU07ugNPKjuPI9KtXvNNnTNmktrQxbO8MXstWTea8MgWk/IJtWGtoZqtKZfMk/RwQEQt3Xk+6kj stfIiEYKY10bqqd5LAEox14jI/JKUvNuqJ3I8fDdnnuN6iiXZUTDl/zaGxqo1LnX+IjedoxQktTz yk7F7DU6osU3JvD/+V4TfO3Ya3TWyr77Qz/PbPLMoiNagjtFR2eM1gByz71GddTLtrKJb8SbvUZH FMK+IM/nuoQyHHuNLki/z1q22FGye41hkPU938qyfxrsvdu9xjDIUJcFOfLUz0/z1vQjI/Lr2aor m939516zI/JSHWP5tObOvdaT3WtMR80tOurkuZ6tDUl1tAD8WlrhBA/yy+41NqK+r+xqAN9sbUiq o+bD2pCJ9RM449xrdkRKknr/sVkfm0QfnnuNrqOwKLtu0dGv2z469xob0eIMkXV0Wv6l2nuNb5H1 UXMZ8Gb3x2r3mnmv+bw+q7VqytHQ4Cc2e808RQcvnNseNSQkJtu9ZkfkV9NfawacAEuw7kM6otL7 2lA1MH3Idq8xHYV9i+QzRK82a0PSEfW6b1qLi5C9RkdUNmXvOQxj1hZ41W8NHSOKbVN2Kuc6Gg+/ c6/ZEQUpJ7vq6BxRKd7uNTuisbK3Y8REaA6iUbPX2IjaEus3+GBOg32ws5i9xhZkbEtDTTJfDh1Z GzLbd/81oprXhqxHazH93NbQEe0Ty2Znv3uZDdVk9hoZkf9ZQ8+FQe40tBbTL2wNnXutbvdaMWZN sK56rqO4vSCzcfrmYvYa1dESMi63SDnP7Jfda3xEYdu0OZsL0roPyYjCmvukhQcNclzMXqMjcqvp 17YEAozI2pB8RGE7RtLpqhf76NhrZERRCg8tn9ZPG1Icmsdeo5+2YDzSkAljjBYWy/bhNwogbAdb NgG62cJimb1pi9vufntlF+uqJyPyK54hIzI6GkE6515jI1p2qZo154J01jdCdeTXp2gXlew68va9 RkfU6z5rp+U/ZMxeo7PWtzPb2JC1Wwiaj2j1sY0C8ucxMqyRc68xT0TY7exmPKPF2pBkRAHU7W9l n35ICRk+9xobkdvftOaZVQkETRdk79uZnU/IpxAIutiHXxJS/qWhdr5FarKZUMW+aSNoBe+GXDob KjZCk4zoMiJ2O9vca8OoPPcaGdF1Qcbtys7nC1KSKo69xnW0+o+u6T99tQMoOfcaGVFaEd/xyvYn li0Y5LHXHka0+diM20eyM469RmfNL97jkRphsexm9hofUVie622LbMGZbW1IOqLlWa2GlmkomL1G RlS0Ks3709zp82/evtdIQ/kyY8PakI/nrBEOBBKfXcWDvjZ0ethbtWGMNGI8he3wL81EjZG9xr01 Wwy7cbKUaG1IGjFea9wbOm9aAkFzHS0vSOHoPZ5Z8qY99xrTUS37FjFxI53sNTaiNX8tOJsKM4q2 m73GRhTS9szy5gU5RnTuNTuia2Uv19GoLN7P3V9suAcZUV7RAtFRPK/sRvYaG1Fo2xZpp3lcl4y6 /NzQuLK3Y6RZt0+we80+/Mqe5LWZS9rQePSYvWbftGkNNlaP1qmjYEOryIj8z8p/FOKW9SMNSWzN udfYK3t91Mh5dN79JLSK62ix2EJWqv69IfteozqKh2vMYJAx2b3GRpTaNqJoAuKy9fmTEUV5Ra8j isdek2joc68xb80SgDRGlE47O3eLr/F15Df7aLl4MaJa7F6zI0rrc0hmzUTWFesboQ0tsINkM9r0 RWtDVvvwy+AfR0MR1LlLQ4W81yp794f1FkkbJcbrxvuPvUZG5KWI0DIiw+3D9hoZ0WgobQ2deP/a UNkaOnWUt3UUT1C8jOf6sdeojur6aSQgjoXn0xEtnnBJ+rHBXtHstYcRLedR3DM8dR1ZPyQZUVqP xDEiEw85MMpzr5ERXeeRWz4t7ZkwOiK71+iIctxG5E1kHfH5k4Y2+jNZR6evNleLr1X2yu5u2yLh jNFi4fnVvmk3dhct6WcsNhueT0e0ePmkptJpZxdnbUgyomuvLc8s2bQfLsiyNXSMqOXl0/LG9qHK btY3QnW08kQMHVlnnfWN0BHVsi3Iej6O5RY595odUVqd/FL42yQLOmtDPoxoP0ZOpCZ3+16jOkp+ W9kGX5PD/9xrdkRVyKTuhq71aVZ2s1g2aagInr98WjwTc8efz73W7MNv8zyNhpKJhyT3WmPv/rrv tWheRwuY+WFEaSWKkC2yniLakMXX6IjSgkKMhgzg66wN+aCj7YSM7pj+USfj3GtkRHmL0RrKNi7W YPcaHdGaTzvO7FNHwhF17DWqo+06iltYI45aGw9JRjQw521EK68WFqS918iICoqd3jrKxohoFl+j I/J+GxFPPDn2Gl2QNe4L0nhGvcWyG3tlL8wlY0TOhOg1e6819qYtZd9rBsxM9l4jI4q7sqOwOG4N DTvc7DU7osGh+lobMs46uteYjtzi9A0j0vd802Z7r5ERFan0tOrIeP1IeD4f0YJCBK0reDRkfSN0 1txCNzOe6yY1L9h7jYyoaG2k94jqefdL4MC519iIWtnvNTOiau81OqI1GjrkFSRFQ9nakPzT0qaj coYxijVy7jX78KviIFgaCifAsro03NbQaWevVm2SxKetodwslk1GFNccBtlrJkar2RRPMqKoJRbe DSULilt8jepohaDHCWnj2GwqDNXRGhITtOD2PqJh+p17jY0oxW36zcqWiKhzr7ER1cPOtjFa9r1G RjQqFGwvyGq8x9nG+ZMRXS+9sp1H5cyFKCTFk+rI+e2CbMZgbzbOnzQ0WKYXY3TnHMcxYtOpu334 1dUTLnb26Yhi91q3b9q6ErLJiIxHK1obkozoMo8XsfFcP1EIYUA59hoZ0Y74DfvoHJHE1R57jepo JVAet4hZkNX6/KmOWtiUbTHIZO81PqL9vdaNEdGsDUlGVH5C3hakM/n9JM7/YUTbmzabgLgazV6j Oqp5O2qdiT8qNsXTjkgwnl1HBl9z1g9JPq2dLg3DoFuLjdHq5uEX/P6CTOuLAiNie82+aYdZc9y0 BqmxcSN2RMOfXTcjopinKNtrdkRFkpPXhtZJu6+jc68xHYX9cdxPp2/LZK9RHa0R46PGkXmL2Pw1 MiKNd1waKicIxfA1qqO8XkfRBp9K1Ni51+ysbSFQ8hYxbEPdxo2QEbWVYkCubMN/VCy+RkeU46bs el5HA1g2e40tyFI2HfUzpap0+17zzrERLeuoWgqMNT7bbQ0d6yj07dOi4fbxNqeGjOhagasNWX62 PauOcRs3QkZUJO1+0ZEh4i7dxh5zHa3uw7YudDRULb5GdZT9tkVWSlXoyNqQfESrS6Oh6N06ombx Naqj3rejNpq3SLc2JBlRQ33J94jMCzLbdGqqI7fSg4732mkfBfteoyPyq/e4EYuN5NSQhupKniEN Wa8fYauWoqXHiOLqranrYYCGCmGrlobMvbbstbbyl2pDmbHo2RFdey1te82QcoxwWbvXzIjSCvBL QyfN7Lppy9bQ6fVbY2uajdIYfnO714iOwhLpOzbt+VwfASp2r9ERbetoJZ7Eyrb4Gh9R36a/neFn 4hk1e42MaHOxNgtmlmDjRviI2r5FzigN0ZHZa2REbkVFq42sWynC8nNDG0uQ6sh4j+17zTtDNLkl 9I+GrI+t2FxRbei8+xfi24A6q1tD3fpG6IjCemUXm3Y2CEnsXjMjSivFwGgoGRq18Vw3e82MqP2s XGNjZZ8cUYySh4yobwG6crAZHbF7jYxojYa+GjLIMaWasyOqW+LJGNF5iwz/kt1rZET12P3G509i tKiOUtoaMmmwo7S03WvniC7LP69ndkO5+6UhifQ1e8005Nb5lhGZzANn40a8IeMM4bpFtgvScGiO ds1eM2ScI5Ru9WiNNH3jYiX3mhnRYCo5bUhzizS71+yIqpaZfX+aM7F+yfohqY5q3++104YUCtVz r9kRtS2s+moonm8RyYU49xob0RICNZRdTiOiklxROmtpP/zTiWWPpD+z1+yI/B4RRVe2fa/ZEQW3 xdVen2ZoHcXtc+41NqKNG3qApAYVtT5/siCvzbXfIsX4IYlvBAXBjxG1bfcnk1OT2F4rdta2dTTu SxPDbv2QdkTjmRU2088m53i218yI6saeH0ZNbnNBknuN62g52EbaGUs5N3vtHFFwG+HE2P3n3c/i IfmIVlisWxq1GmxODZ21XDfTj5BMk/eaHdF1+Ptt9zsTNtSsz5/rqHx+1EjCgNlrZEQpbbPmzmoe a32R/Kmhsq6jQT9jYkaJDRnOh1/w8rC7/9hsNQ9hrjj3WjBv2mFELFukr3lxUHYie82MSNyHywlZ bPbqyGY2e82OaIRVp60hY414G6NFdbQlVbTVFICOksXXyIi6VMVbdBQNsVshNqQdkVvhK7kgz+CK SihU6YgWE02vbBPuQd5rbESxb1d2N7vfJbvXzIiCPloWHQXDNOhsPCRZR301iMaIbPKys3H+tKG1 SNnwRJhHDYnR8uF8+I3d77cnRDvZqhm3jzZ06GipJzIaiiecIVk+Zq+RN22K+712ujQkzcPsNfPK 3phuddOamAhCDU51FDdrxIQxyi1i9prRkV8Jj0RHxtCqltuHjijuVq0/DfbBzG33mtFR35NzxojO w99bbh86otC388ifmeIjyNnuNaajtFm14QTqxsPQ7jUzorhGCsh5dL6y23Ie5eeGwpbiKabfqSMS 508KJ+U9PP9S9qmjESzPKzAdey2mzaptJwg1+rFbhDyO3e5AMI5xKQtitgj5tM3F2tbUUSi7V7JF 2KftbxF/BnrXQEw/NqK07rVRVvgEMytxHzId9d19aK3aaBm9yYjinr7YbFj1+HK7RYyOwn6vjQEa mJ5tETai1TdSfzZyD4UObTo1KS+zcfDoOjo3bSCwWDQPv/jTl70WvdS32RvKxPSL5Cm6hcRUAR2O hmzamR2R32qm/opujZDRhgbRn9lrZkTDybJXzqkWqCOueqaj9e6P3lJfDlTK7DWqo33WDEGgxGef e42NaA2rHiMynojhPzr3GhtRXjOh6sYVjZVNriM7orByOMuIzL3G9hobUV09o6Nu1rmOSLgHHZFb igJdI7JUKp24NGxDfstejYH4s7NN8ZQcx7OhvsREDB2ZJwRh9NaGTh0tsxaDlMrYR0TSzuyIRnz2 4kC49toGrutes+H5dkRXQyszvDRkYDHi0qA6StvK3iKr7gvS7DX2XF/utRhsZcERtmH3GhnR6vSN W8zOHJENY3yYtffKvkZkPRHJUvKQEV2Si9g1IptN38kzy47Ir0OQlW2KlCUb7sFnbWFliIPpyXjY yb1mGzKzZggnSiIVmBJ5rq+hnteInGWuIMU3k3mK+jXadNz9lvU8Ele9GdFIxF7Eotb+3T8t2pBh OyK5IDdrxKbBZuLSYDpqZTshnTH9HLnXmI7Wu39c2YYCIxJXPR1R22+Rk0xhXUd+a+jYa+u7/xpR OA2tsWfMXrMjCpv/6BoRcbGSZ5YdUdj82WNEJho6EvehHVG69sR2Hdn4o0TCPWxD8Sfspp+hmquR hHsk814r1+NjG5Ep5tK8TTvTho51tBYDHtNPax2avWZcGhuR31C25YeMxH1oRiQNbeuomXhIQg1O deTLdtSaaJ/myHvN6mhQg+9mjcnxI5Q8dERucUSNo/aEoMd6tXuNzFqPmxFRz+Tlyqqd2RGNdNXF 8h/VQc/dn0i1MzuiQVn4FhsXpLmOIgn3YCNaw/Pjds2hoUzch7ah62DL+zoywV4stCqZF2RagVnR kXGxRrbXzJv22v1+m7VkDPZi087siEbcyBI4EBW92BoqnoQxmhGJG3p7+BHKQuIbsTqKK13+0JGx jyqh5KE6envGdESG0rmwvcZGVLe9ZrdIJO81O6Lw048RGe9xIrAYG9GavjhGZKbfEViMjWiNho6O BMMn4qpnK7uk/YQ0sFghoVXs02LcPs3U8JVssXOvZfPwy1vmwTghz/AzGu6RzZs2rGnPch4Z2qJA bEgzorHX1t2vnvmtIVrF04xoNBT3hkwAirfh+VRHbQn2GufRadVWknZGdbTy+Y9ZO59Zgoqee42N KPRtRKZCpRAon3uNjmi9+9lN68l7zY4orcnqch7ZfBHiG7Ejils8pLyOjNfvZfcaG1Fs2wkZDA1/ tqkwpKEg3D2LjgwzvNQ5NnvNPPzSSgWvNqQJ0iEhw7YWdNx4j8UTcd60LGTYjmg8h9raUDtZ9ApJ p7YjGqB42/ZatvWOiB+S6WjNgmYWWyU0/FxHbjuzLcV8s+Vl+IjSNiJnXkcsZNiOaLxitlkzSE0l dMUPOtpuEWceNYTWkeqo7m/aZGCxRt5rdkR5JfITj9YZMzribu1eI5+2sEvJe81waDYSWlXMw69t EeOyaV97Q61bGn5t6LSP0m76nanC1Ia0I/JbgG7cvEAv7DViQ9oRDRRi22vWGF02bdkaOnWUtsO/ nq56Ib0/9xrT0bLdxclyslZJ9OG519iIVpx2XEfnvTaK1dvq1GzW/HLUOkt/JdfRudfsiPL1HNpu WndekOOVY6tTmxEluZLXTzPhHmP6z71GRxT3vXaGw4on4txrtqHLhlxiRsesmRck8/kX8/DLm6GV oi3hnDuBoIt506aN9H6M6PXaG6rMN2JGNLJXlydE0qyOraGBLdm9xgJQ8r6OTOg5SaemOqqLxZai uPgPHZFUGKajXLZNa8pdjaVu9xob0XL3XyNKpmhiJ/caG1Far+wB1LGb1uw1MqKlyv0YUTijD6XY ndlrxDfS83b3N+OrJVRzdERrpngaTIMnBUYl95ptKK0X2a+Y1ix9jMgRG7KYh18RroxlRDYP0hHf SGHv/iVd6BpROaOhSyVYthmRZIovOhpGxKGjVEjIsBnRaGgRS25N90dDlfghuY6Whlg+rbOUPFRH ZUWzkmTi7Q014hthIyqLHzKFFSZBQ8GWl6EjyuvjeCx0w4BiKXnIiAZr4nv608ar9MLKJuH5dkQb AZvo6Az0FhDK7DU2ovUWCTbxJJN0atJQXMuci46sfWSpwX1lb9oFPBj3mikIyEKGq3nTDr6rRUdR CHN3HQWSdmZH5DfWquRtneNhiJm9ZkYkNQmX68itvAEv7DUSxsh01MN2HjVDElSIDcl0lNZX9jVr Z0MS63fuNToiv81as8WALXUBGVHceEbHiCwnC/H50xGlfUSm9ipLO6PraMXXoo3SqKREIRlR2Ygm ZWUz19i512xDeXfWJZu9yqpTS22b0/J3y1tknNkmaJD5/Kt5024kdXrTGh1ZmhAyomuvrTq6/ng6 NDNLhbEjGru0bw2ZcqAsPJ/qaPFnp/SzgaKqI3KvMR35/V6r5i0SiG+Ejshvu7/QGr5mr5kRXVuk besoGcA3EN+IHVHZXGNDR2cwfHGW1pHqaPE7/orXsrLZYiTFk41odfukZMuB5k78kLahS0d92f1J vuTQEXmvNfPwK9e7f1mQyaZ5CBXvudeaedOWteSS6MiE52cSnm9H5Dfm02uLBMNZF0jssR2RF4h5 aciUc2Al5amOllhz1dGZl01KFHIdLTdtTLYAl3gizr3GRrSmL6YkzzM7onOvsRH5JdJ3jMgmeRHf iB1Rvky/5YRMP+n0+a/2UdwaOvbaSjI9Vrah5GGxx2xEpW46iqc/W16Q516jyl69fpmkwUZLDS7V A/aG6qkjZyp5BeKHbOZNm7ew6pgZUkPea3ZEfqOaG1vkpMCQAu5mr5GYiDVb7GrI0KjlQHwjTEfr MyttBJaLjsxeIzqK6wmZSckLT+L82YiOF6RJ8ZRMcbPX2IjatteqKVQS2V4jnoiyoOtDR+eVTX0j dkTXyl6jxvJPNTpilDxsRCvkc+konv7s3IkNyRpaWauuEfnTYJe73+w18oJcfbVDR+fdnwnVnDZ0 6Ki4zRrxJmKc+UbsiMJWES72n20Z6YhIPKQdkf9ZwhbFhjxnje81oqPlOaT2kbn7CZbNdbTZkMVU Fyokzp+OyG/WiIHFhLHS7DUzorwnVVyfZkI9Sdk0MqKy1TsaZ/aZCpNZ7DHTUVxxkVEYwCR5ERvS jqit3LvDN2Kuo3E62L1mGqorVYXsflPKqRI/ZD8ffuIJ3/xHzoCZnsT5d/OmLSsdrO5+Fn907jUz orHXVqdvFwbnrSE5Ic+9ZkcUNofm1VAzrvpK4kaYjsoSVX/N2jb7d3DFudeojvJ2ZkcaNnTuNTai vGTUjRGZTevJXmMjqrvFlg12VIkf0s7aSHzccBFveNhZ3Igd0eCGXrx+mQRWMp8/G1FcQKjhhzwt f8ldP/eabaisEXByQprw/EqoCzp5ZW8jImScJZJ7rZs37XCybDqypS47yamxIxqm37ayu7GzX+S9 ZkcUN/K7a69Z8rtKfCNUR227Rfr5Fimk5AXX0ZJ5cOnI5mV3kk7NRpQXN/R4HZ1BOtQ3Qkfk9hPS oOud+EbsiOpaJFNtSBPFSrBsO6K6ZdQNq9ZgkJ34IdmIlhoXv1ImfGyO2JCsodQWHW2cihhRsr6R YPghB9td3uwjg4uUYOMhg6G+DDuFaixSuekYUTZ7jYxoJBot6yisJeu0oVHs5dxrZET+J65uHxLG mEmZa6qjhfNCfCO2Koz1jVAdbf6jsjoBFx0de42MaKPOGeuonyHDA3879xod0QqwxFGM0Xi0bIlC qqNN2VnycHdldxt7TEe0PPTGyo4mMTfaXFE+ovUWKdahOUoxn3uNNrTdtIXYkNn6/IPhhxwUA6uO qq0Kk5v1+QdDfTnChlZrpK70bBhRsvgaGVEQou17RHF13mBEweJrZER+i4m49loxxe6cfa9RHS0U hUNH+QSh2HuN6iisuMi4VEx+v/X58xEtQcxjRCf7mYzI7DUzoroRKcW61rzHiAgHAh/Rivhde9gU BGyWhp/qyK3Rh9d5ZGLYM9trZkSDQ3NZR90aEWtsTf7U0HJsDPvI1F/j99r58JOYvMViu0ZkCrhH i2UHQ30pdGfLrF1/NP4juteYb2R/QcaTS2PAZnav0eyM19qQM7VXSf4a0ZHbsnxER+Zes+81MqIm ZYjudhvxsEcbo0VHtKZTp269fuIZNXuNjWjh0YqNJJ1mG6NFZq2voOOv1OwWYaV36Yi2jLpGcJFk y6aREbW1wJGMyPqP2L3GnCxl05GtwJRs3EiwRJNtS6i8zqN6PtdXHbmtoWOvLa6HMSITxCyv7HOv MerLlblivNfOFAZqQ9oRhZU8Q/baGTG+XpBla+hU9uIYT3W9eBcdnXuN6WgjU2i2PLHo6NxrfNa2 W8RE1rFyoHZEIzV8Yc8fs2as2mrfa3REC9vdGFEwMREv6xuhOkpL6d1x05pkQeKH5DpaEgaGxWbQ LEI1RxrqKwGbOOvMrCXL7RMsP2TfqAvGiAw1OLvXLPVlXyuSjhGlszAAvdcYPWhdNu3waBlUlO41 EjeyslWPvXaGe+Slhm/ZGjp1tCI1l310hlaN15Lda0RHa6Hb4a0xZJzMhjQjGlvEbSdkNhQYkbzX 2IiWEidjrzVjsRUbo0V0ZM4jQw48ICG715iO0ray6+kak3JXZq+xES2m35g1w4BC9xqZ/rj62IaO Tk9EtlRzwVJfjoYWHV226Qlm0nvNUl9eZ/bxpj0/bU06/TCia08sZs14Zpl7LVl8jYxoxI3sm/Yc 0bppy9bQqaMlHHbo6KSbkWifc69RHa1+yOvwPyOimrNYNh1RWKMPrxGdR+367vdbQ8eINp9/tez5 Q4dmr1Ed1d2qNSXlSSknPqLdx2YTmDzZa2ZEO92Z3P0mAmHhGsvPDbk9jm14XE/KQhI3Egw/5Egy TtsJ2U22WCW+EUN9OR5+C8/oGNF5ZjdSotCOaCTmps2l0U80K0fyXrNknHF/igZLXLI2VLaGTh3F zRrppvJytbHHREduc/tc66iZtLNoff50RIt25RY5N60UlzJ7jY1oEbtG5E9SjpFubfeaGdFGeKT+ o/NeyxbLpiNaq8EOHRmigGh5tMiI3B7rV6Ui4T4iQsNPG2prjl+xdHyjbIjda+SVvd39zb7XpLiU 2Wvnm3bkmK/0DmMdnWd2JTYk49B0fnuvlXMdDTzY7jXGpbEnVRhq8JyIH5LpaHv4NVvITXRk9hrR UVqTTqvNX2uV2JBsRM1v7/5mipRFy+1DR7SC4uOmPZ+ijWDZdEQrR1Rq1lXPylyTEfmfXLeVbWgd WyHvNTaitNvZhqy8ELpi0pBf6RfFhjxfR0KkdO41QzQ5aPPSttdsJEuyuaLBcGgK1+U2ompHRHwj jGfU+22LmErw9F6zrJ5xq5vFwj3ovcZ0tBa6TQPdOM+jRPYa09HyrBpvkWDoip2N0aIj2qI02qr7 OSKbv/Ywos3Hls8nxMgnMXvNjshtabBj91sedrLX2IjWarCXjvzJXDGK4Zm9Rke02kftJ9g3LfH5 M2WvBxvXEXmvGaLJ0dBSDzIPluEvcmqC4dA87rWRdmayVyuxIS31ZVqf1QMVNbM2Co7YvUbiRlai gOEbOR1ROVouVqqj1YFwvUW6IS4hOTVUR6vX79KRRWoqwbLpiFZ8rZMCpZG819iIottGFAyrZyP3 GhtRXfdaF1zuGJGNPaYjWnJfRtZhO0PPx7vL7jUzorCmGf7KfiVDmyMi7zXa0PoW8TbneEDJZq8Z oskYfxaf2hiRrQeZiB/ScGgOlrKlwERy1qxpzpbetSMabEOrxZZX/+brea9ZVs+0oetXQ94Yo5H4 RpiOViqVHNY6AVNHJG6E6Wj1H41Zs4Rc3e41OqIltmaM6Mw7Ksnm1PARrSfk4PYxRJOWs46MKKzJ 6jIiE6MViR+Sjaitrvphd52e0W5zauiIwqGjM/xMqgude41+2hqk42wpp+ZtnH8wRJNjRAsTcyZ8 /iynJhgOzREiHrdZMwlMjZRysiMaZFMLt8+1RbLJgiY5NXZEstfy2pA3KQzRxh5zHa3ryIuT79AR iRuhOlqNUSdFFw4d2bzshxG9D7bsLcBSSHkZOiJft1kz2JGMyOw15q1ZYv3y4PM3NiS51+yI4h5a db0DT5eGFOEwe43paPH5j1kzhO6BYNm2ocETseloc0ToXmP3mnn4hRUtkBGZvRaJz99waI4Rle3u r6c10gJ5r1Ge0TU747IhTwdCDsTnz5hP11IFV0PF8PkHtteIjlagLhNmeLGPzF4jOlpzasasnQEo w+ti9xobUd/2ms0UT8Q3QmdtX0fJvCCjzV+jI1pyFmREn3DauDV0jCi57RYxMaNCNWf2Gh3RtrK9 iT2OBF+zDV27/7j7T1aGRurUBEM0ORry24iKyYVINi87GA7NQQwRNhsyGdprUjvDjkhsyA0Wa7Y6 NbnXGKtnbdteMymedK9RHe13v2FkojYk01HfbxHzhJCVfe41NqLctxF1U8M3EZ+/HVFaeRwln/YM YqZ7jY5oyYUYFps5jwjHOF9Hfdtred2zNy5y7jU7opGzsFgjSpu1j4hwIPy2oaGj0w3dMonRMkST g6tg2bTXiKIpBd5tTk0wHJojfd5vZ3Y0SE0hcf6UHXbPXTeUzsPpZvea8Y0Mq3ZryLz7Rya53WtG R2mrnTH8R8ajxbBsqqN9r+Uz+rARjnE+onWvDUPrvEUYlk1HtPL6dRuhOWhE7F6j62jzscUzjLEw LNuOKO+oqLPe4+GBtXuN6GgZgozodTRUGvGN0E9bef26LQg4UonNXjNEk+MJsXCx5vCzoRk3un7u NcOhGctlfmw0Ic7QzDbLN2JHNJ5ZK76W1njd1+sRX2OsnnlPFc6nxTYcXmavMR2l5agdOjI1xTOJ h6Q62n0jzpxHjWDZdNb2EZlSlyWTvcZGFOt+Zp+h58MHZ/YaHVHbRhRskTISe2xHlFcHtrwgT7eP 7P5zr7ERlcWsGTet8UOSXFHSUF5RcMGODJoVic/fEE2OXLywvfstKrpwjbmtoUNHKzd0GhTz54hY /hqjvtxitJLY51tDq6s+bA2dvpG+b9rzGKFYNtPRol1Z2TbnmO01oqO+UjuFn2LO7ETuNTprq28k 2FDPdR35raFjRJsjyluApbH8NTaivGJHzA9ZSNwIG1FpGyqarVVLcmroiOr2gjSZB6UQG9I2NEa0 2dntTKmicSOGaHIcI+u9ttUIwogIj1YwHJojdGWFDsd19NobGlz2dq8RLo16RIyb/LVEYo8Zq6db Q/SuEZkUhsTuNaKjsvshu/H5N2JDWh0de23jVNSGqM+fztoCZ8jKPk9IwjfCZ213+lremm7rr/ER tc0+8mfiSWH5a1RHfvceGz7/Tt5rdkR1t2qzLQVeKrEhaUNuG5F5QrRgORCCIZqU3ODlzB4sj+eZ XYkNaTg0x4iO68jYkIH4Rhj15bJuxl4zZg3da5bVM0vY9NJQPCHoNYi5bA2dyl79kHmtETR1ROL8 mY7WuutplBg3EQgk9pjN2qqjnNeceIyoEHyNztpO7+BMZB3z+dN1tHAgjHV0kpUXwllHRjSC+zZr pNuVTd5rbERL1KroyGTTZ2JD0ulv21vEm/J7ie018/AbWe+LNXKtIxM1lonP33BojhS6tO21dy9z RIXEQzLqy6XAkUaxnrCYJ74Ryuq5RiCMC9JsWuKHpDoqm44MdCivI7PXiI5i3NZRPQO9WybvNTai ELYRBUNXnIkfko4ob7NWzrzs4QW2e43paLWP0s/mYNfdT7BsO6K6uh7kFjEedlLDl44orYgf2bTr eZSfG6orF7iQu5zMp/I6OveaIZocs7ZQFl4jqmfYUCmWRysYDs1rRNt1lGxyjli1/5/23jbHliU5 DuzfXEUtoKaQ8R2hBcwCZgNEgyAkAZwWwW6NqN1PeuSpc8zdLKsOQVAzAt4D5mlus6+3Hc/wCP80 j7bG1JcVF63v5yg67NLWmNWzugKLNloRrykd4dLEVjk11ruwNaUjR1kovNpZxVy2RIQ+pGKJ6SI3 ohBBc9emvaZXpIt+SIWowZBXq5u+PyAStWx5jrLz/InZa1bReyx1BCZitkaLt5WtsaCx2RZBRzN6 tVtHZGsU+J0/bTkfkoYq0M8+nKBwQ7oxDyvbxvtI9fkz9aURBLqLrdO02OjC1kRuxA15DUF8K21N 6ejwOoqJ8R0dka0JHSGXht1HEdH+amRrAhGs7dweG9naVLYmEOXqEFFwvCs1ZGsK0XCIMs2LTJEb kTryLy2RKMo+f0a0HGlZE+7xyCJek4KwJ6LgEOIDkdidkYlo0vqo/Z2dqGU4K1ujmHYhi+tGROuu xE4oRmRE3Dji2TdpnhPUxJ4aRrSXuThBPAY7xFy20hFQMH22gosrQEdka0JHGZJ11V0GH6+vRrZG iCY2Ze2vFquiQ/FoKURQmNvDgtHWzOthWxOIFiIqnD/C1SnFCQq25jaeiP0icypbE4gK5moLdjV+ 64j31OjPj96IjWqFr7bUTA2zehr3IeTYOm69/vi4fdeIQ7NeAwGgoxmVvbKorzH1ZXXUl+dzxJx1 WeRGFM9obd7WqPdYcLFqHcFfa21PmQUdCR9S6WgEQveYZFkqN6IQdXj7m9U2P7wg+a5JRNieX7ni Z5lTsjWJCF+RjkPR34gEZx0hslIxLimrzOm7DsHtIxEdLluTuboueo9Z0NpMgk9ETUzUDZHzJ6JJ u0ay+2qUqpc5f+LQtJVLviOK+2qHyEMy9aVt3YCLbWA70sfD1oQPyayezTegDC6vtiLeNdbRwg2A pqNB+SOx65ARWVsG1vsbt8NaXoBtTXw10Mn+asQPOUV9TSGaoQoRmwZlLVvpKMM60J0/Cl9N7abX OipORyMW6vbJJlsTOhqQGG9tk+Z5HS3eKyp/WqhCHORnT+6HLEQ0WTxvjekofjVceXE4QcHWkP9o EwTGWKTxTA0jMgZddCKWaBmuzA/JiGyXT3Hv2qS+kcLxmtRR918tEYli4t5jqaOCL+3Alq2HjkSf v0S0QmaUPX/2ITWi4XK1i7rGKudGGJFdtXBDGqL41UbmPKREBC15m7oglg6n4PYRiBKuXfhsp3NC Y2cH5/y1IE8TAktiHoi6srUY+FlXDghqkwcqx8E5/0IcmoYoOdfPdTJc95GyNZEbmbhZcPHJVvU1 RpQ7cqdsuhki4xT9kEJHB972pqNK9OkHc4xrHSE1+PnViEmncx5SIsKhCjtHxKWxOOcvESU8R1YB iq/I5Pk1eY4S0Ki1ybMQQ+xfu0HkdUQ8ESI3onWEmYjzZJPHJt61m58G/lH/ylGQ5XLZ1mLgZxcb zkK4JXrfiNiHLMSh6Sm8DRFdbDbNzLYm+kawul6dc3IJUrzHjOh8IA/MjC5kwnwIquxDSh1Bmmfr iKagF+dGpI4q5kY67nR96OhQtiYQNX+yqYm5i33ZEtGo7hytFnSkciMa0XLWT+uuNiKyNUKUqJUh tujtnlGyNYGod/eKuHT282STrZGg9DWw3t+Rv/SBaHF9rRDRpLl+09kapcakrRGHZg2bBe2GjLYm 5rIZUdwsuHAs8hKEdMXZCQrvGo4wmCAqHmTmG9E6ghSrvSLEfqZsjXWUvw74a3ayaaZmMQeCRBTO UaPdGaLPXyJKuKC08320DuZifQcRivl4vrTR1tQ56tXdR8Tpa5y/ZGtvIKLmCvmusaDkq+sdGxK+ dcScdYWIJqsbV/1sA/ssL0Hb8ydbo9xI9gQ49q7FPOTBeUhGZOsckBl+Cu7DwX3+jGhvqHTvWuEB b/GuKR1BN8V+12gVeGJuH6mjiqN54/z8ZGuc85eIFnaNTb6PZLwmEXWPKL5rU/RDCkTWRu91RFuq RM7/5hw5gsBMvcfS1ghR8d6IaBsajXuPpaDk89lUhbAIg2yNiCZNEIRZJyI+R43n1wpxaNpPO5yt EduQyvkzIlsLgso2r/bDC8JUfXaCgg/p1oEKE7HpQbI1paMMF1sTCc0hZmqkjgqmfQYeq4eOEvce C0R5XxOIKDoRQ+yE0ojwHLU99ugRVc5DSh25KeiBlcRvHYl3TZ4jaEDROmK+Ea0j7GQZzJ+9ibij ramfVpEetIkaZGW+kUJEkzbXAYNwzSrSlGNjHq1CHJrWbIwzfh07rR6IoIn5HlEOTcwWr8V3rYl3 jblYB7Yb7gcyBjWWmmBbEzpqWKc1FuwPL8j2RbKtKR01pyNi91iib0QiQrfmRNRiUGNfkW2NEFnH ibshJ/mQnXuP9TmCoQrzannRLfdoCUQ2Te/v7FjNWioPKXU0PSK6jwSPlhBUv2AYZ1OoxhEGVcsu RDRpVfDl4rVC+SPBN1KIQ9N05FuGa6S/WoJvhBHt5Ztw1U5cMnwJapX7RhiRFQ+wY3zxBibbhsa2 JnQ0k/tqFIqOIuI11lF1BDhG6xjrIutQ7xohKjiOcZ3s2BMBPKPJCQqIoLfvIuKOd3ZmzjqtI5+t 6byCh/v8NaIXAtMR30eCH1Lr6PC52phjG4L3WApa3XkjTs7TG4m2RkSTJqg6HVHax3Yhkq0Rh+be tO0yESO+a3OJ3AhzsU7k3r14/cJPw/b87ATFPKR/ILkBpYn6GuvoNBEo+Vh0FDnGt46irSkddRRk /JAxOhrMNyIR4RC82Rp7tczFqhFVp2zuPhy8O0PrKLkIssTJA+lDynOEDXGJlb07NKOtMaL2VcGr 7YkXTNhDTLamBMF02NYRzdSIfshCRJM2QwVPdhf8RxsR2RrFtDbV5TIRlGRZSfiQzMU6kRFQTmZq W6PciO9iPQW5ssglqAhbEzo6wGPrB058go7I1oSOHNXcwRtPjFOVbY0QnbbW/Vej1SlZ1NfkVwt1 EYr7BT+k1BEsy9gnO06LjcJ9IxIR9Jtt+ivKH00Rrykd9e4QEe/x9mrJ1tRPw5d2iQx7ErVsIpq0 GSpoQDkR0Vj+/mrR1ohD09IzOAozRT+k2E3PiGxjLvw1u9iI91jZGnOxngEahqKZ9xyruWypowkV v1NHg7s0RLwmdTScV1viqPBqIl5TiJq/IXnRrbI1hWhgxc8QRVszhz3amkKERAGGiPOQIl5jRM2N MOxKTfSzM/Me3yBy75o72E+vNtoaC2pnmOV1FM+R5bvZ1kTgBxvbN6K4o24UnssuxKFpiHAUxrbx UbZG1LKZi3VsqpTvP9qTHYMa2TfCXKxnyIjuccJy20OQ4BiXOmowwHTq6KCFyWI3vdBRdzvFqy3R i/dR4d5jiWj5r1Zj0yDG/ckJCogOv6DUff0LkciNSB1Br5+9/ZFFT8Zr6hz1ETz/eI4Kz2VLRLBw zRD1mEAYgs9fCGqe0dsamUhHIjdCRJMmCFZe9INT9XuRG9kaxbT9dCKcieTYx7b7s8nWKDeyXCNT O3C6+hKE6cPsBAVbc5SFiWuQrYg8pNLR9Dqidtgh5rKljiq25+evRIwDyodUiFZzJ9tlD59VCLI1 gShhwTdh4y8gIltTiOCvGSJ611S8phAdy3kjhRi9p8hDMqLhGHRPREfsGB+CH1IKath8anzK8aVV eUgimqzDrXBu1tRKVCrC1ohDc29tdUST3O0j+EYYkS1MxnjtELzHnffUMCLb4D0coslDpyI3onQU vlqi6GgJW1M6go3t+xzFbmjZo6UQpeUQVYqOpqhlK0Ru/d7ahCceURO5EYUImCU3IqodqR4tqSO8 avMZQcZ8tspDKkRgpPqriX3ZUlD1Wb/Gnr/IjRDR5K45g1eb8SM+EFXR508cmtUtf75Wp8RzJGZq GJHl/DF7XL5WvLNtTpJtjXIjyzV7tYsw1wmyn862Rjqyxkp41zK+lw8dNeFDKh2t7t5+IncxZlS2 NYWoOES8nLwpWyNEYVQ4Yc7lG5GoZStEOHfU8/ZiAiLely11lH0IUajiJzjr5MlGvtoTUYlF8SH2 igpBE/OFdiBpj5/s0SKiyT1p4s9RnKhDHR1OUNBRgvqaEZbG58jiObI15mLtu8gEP23FcN2mdcjW mIt1um0eNgQfCQJxCUd3gkhH4LFlEWUrH1LpKONgbjkjCjUHGW2NEflyhtlaZBzAc5ScoIAokN/1 GK4vsX9N6mh5W8ts/cwxLhANpF80HR2sI+FDyq+GOkq8GGAIHi0haGLHyX5p+WSLd42IJk1Q81F2 nMsek3cdFuLQ3F/NjcGCk3sJUnwjjMg2L6PRng8vUc1l0TfCXKxjN+E8BRXBe5xEbkTryGW0cnS0 rJbItqZ0hCvBOpa2HzrqIjciEWEV4vxq8ardX41sTSE6PCLact5FLVshOqrLH5XYODAE34hGhDXI zs1eGxHZGiFaewfdE1HdnEAeURc+pBKE7B42lh9przcrA9kaBX4Lt0kZIlgPCYjI1iimXZHYzZ3H q5atbE3kRlwesvPmHFutwrZGuZGFLBxbUKR2sp3ObGtKR7AQcOso/LQheLSkjnpziDKzxKh3jRBN nKA0RJQ/GoKzTiJqOFBZ9+vjBO3oiGxN6AhahA3RoJ6ILubXFKKavPXjlX2bG5E6grjfENEN2ZSt qZ+GredV9NYcor5GRJN7+bOztc49o8LWiEOzHa6ccSIqMVm3iqhlMxfrPCE4ZVPc3w5ha8zFuhx7 vgmKLy0ul+pOUNARlnxMR+yNiB4t1pGVHRzZVKEu1ixsTSN6/TW7sznrJ+I19dUm+tknotjKsPuP oq1JRNDuYSc7Fg9GE3PZChF2jdmdHS+2PeUTbU2e7OoRcUeUsDUSdCJK1b0i7NWqPCQRTdqTPb2t 0bvWxEwNcWgaIvRGKi+YWIk5xhmRlaCR1bOfF2I4kJbMY1sTuZEjOWeU+0YEZ53U0QSv1r4aTdOr eE3qqLivRptzZB5SIXJV0bpJzgMi4UPqr+Zo1FosHWpbE4hwCL43zNx/IxJ5SEJkG5K9x5apBnmI uWz51ZrzIYlEUc7UkCCz/uxONm1gkjM1RDRp+ULMHpfNL+ERTVHLJg5N20v0+kqSHnQlMVPD1Jfn 5+/ORBJRqIrdGYzIAr9eUFAmDoQsbI0QNVeasa9G/JA7wx5tTemo4yqnhgHlQ0eq91ghggrv/mpU XRc8WhJRyw5Rj/W1PXUYbU0jcjrier/g8785R+7tr5GVQb5rjChhoL8RUWPlId41JQh2f++vRnNH WeRGiGjSEMGqy172LwmIRI8WcWiaoAZfrSKTwQNRUbYWEZUDKeE2R1RMjMu+EWb1PHBXigkqkd5B 7fDVOsLaUcXZwW8dCR9S6sj7kER/tTLzaAlEhxvLt69Gnb5qLlsiwuEcu0biK9JEbkTpqGZ3jgYt KTtELVshAt1uW6O+kSzeNaUjpJjfr0h8aZfoG9Gf38W0Lud76Yj5/AsRTbbLj34iEjRqY4g8JHFo tuyJb8te2O0RTdHnz9SX18l9Cjqfo3hDypkaZvU8HK/fzo3EeE31HisdIY3aqSNaC7J1RLYmdLT8 21/JPxqiH1Ihms15bGS0GxHZGiEqp3G5ughb/xA5f0aUHM3siWhRLDJE77HSUUkeUcyMriZ6j+VX 8+8aFaFs7SzbGgnKnoq3I4vRx+uGjLZGRJPtwGkcQ7Sovia4WAtxaO4mCBeLLMpoFVFfY+pL25Lo bS0qW+0VZUSnoOQTmile/nJ+jXWU3IE8z1GiPn/BxSp1hFz1rWNe6uPj9l1TiCq+tE2wVsE5Sk4Q IXJ0fD3+tD1zHG1NISpYX2tfhTLsU7xrClFqLoQo8fLf7LDR1hQiXAe6o2yqQoj6GgvK+L03ZSHd R2J3RiGiSTNaSPsYIlrldIg8JHFo7t2Wr7/WBnOM75iWbC0isufIc2lQZx2uuc5OUHjXXLPXaWv0 QDaRh1Q6KtnZ2hEbULaOyNaEjponLunEWbeUramvBuXVLi5/jEWSExS/mie/IzLOuYQPqRBl9CFt NzAhEvU1qaPkEHE1S/GNMKKyWYSfiCaW/z/oPmo/CZqeSmXGxgHjao22Volo0noXwPXrAwE+EC3u G6nEoXkKcmuK3E6OB6LMOX9GVK4VO/DTSlQ20l9lJyi8a7g7wwYqufeY4zWpI1yb1q2zIXpsYteh 1FGbDhEJWom5WCWiAzvrhliaKPohBSLbBwnKXpgD/kbE/ZD6HEHSt5+CYjljDM6NaB1hbsTxcn8j 4j5/iWgCoXtfXPC1Oz3amhBki5M8rSN11hXmGK9ENGlOBPDV9rGDoYCI+yErcWg2V081W2vEVQ/N XveI8vLza5OLB2onFCPKgRxYjOWjoO4ERR0B38i+jz68oK0jsjWloxeCi/6K8kech5SIZnaIBnFE TeYbkYhWIOWgHvbCOX+BqPh52sEj55bNYVsTiCAXcl21lD/i+TX91cCJ6P1rcEcUz4oKQZYwcogy MaBk5kCoRDRpiDCCHLxgQvVoVeLQtPQM+tljM8p7RJVzI4zI0oeelYGoeM3JYFsTuREXQc6vGicP sNmrO0FRR9Wd7IOjI/YhpY5qcT+txUbv/dXI1gSi0dxXcy3sz69GtiYQOdrr8/OPeI4Ej5ZENHHm uOM9941I2ZrI1izv1iTqicicG5GIXOW4c6pe+ZBCUHVMzKajmKrf87TR1oho8vxpI/lzFMv08+Ba diUOTUOU3FejfkhLA5GtMRfr2rw0T0GTe/3aIXxI5mJdkYwzxX2Q5qyQrSkdzcP72aiiy88WPqTS USC+5a76wnlIiQhWXGxvJH7+sZhvRCPCG3Lygok9BxltjRFVRzVniKLRzkP4kPIcHf6lpT01Iucv ELnd3/urxVEYy5STrSlBFVcVTBxB/vjB1ijwa8gHut81Xk/MechKHJomqPh3LT6QFi2zrVFuJJ1W 6n5aodaqKnxIQmTxmo9pc/xqak+N1FEpztZKzGfv5eRka0JH8Ll32oe66iv3HgtE1RXF7WTHrrF5 KFsTiFxf7WDiEptnZFtT58j72cTtMzPPZetz5BdMVOo/qpyHlDoq0+nooMUAiTkQ5E/DXYfWf8S8 fsKHJKJJu9iA/eyMIDvFtKJvpBKH5gnhmC5eOygWmZyHZEQl+ZmaxWxDNlBAtkaILMmCnXW2s4w4 xnkuW+qoY6+fDSKQN8J9/kJHzftHYxcdvI5EfU0iaphjW7jW7xsR5/z1V/OEpcygOzgPqXWE+Wxb yESVY56pkTqqxelo0X0k6msCUfnqQBBoeUiKspUPyYIast3tMdg4eKK4fSoRTZrDDiOeXXDVyzwk cWiajl4I9hgs2Zrgh2REJXvOusUvreobYUTlDNexsXJx0tcSAWxrpKPmRs67YIbfrwjZmtDRKBBm WV4qClrMWSe/WvWIJlVFl8hDKkRruYtt0DR9YR4tqSMIqz6HNW1QnZZr2VpH2AxvTJjR9RN7RfXJ xgjSdvnETMQS75r8adgPuURvTeW+kUpEk+bV+q+2aN3Vh7I1EWVj34iN5vFGuCZsjXIjNvXuBPV4 stWuQ0Z0ClrYD6keyKbeNaEjMK6dz6be46VsjXR0eiNQFT1tbRJ7/uDdGfqrActwn18uf/CsZpGt ia+GlM7dLdL5RiRy/grRgZf/5AnfrSOyNXWO0PXLZ0RBiLgfUiCqbuh0uM1OD0SD+SHlTyvd6eig 9rPFPFqViCbt7YegxhARt09n3uNKHJr2rnlqp0ae/yHqa4ToNBHs0TJmr9jIhGFWdoJCvDZwWNB2 31HxgGdFpY5wwvfU0aC+ETG/JnWEGyr3ODXVsnmmRiICempD5M7jRiS4WCWigk2Ddv6oY5x5tPQ5 gh6tYXd9fNeGiNcUog6zEHay45NtzfJka4yobAow0BH1HqOO2r2ghjvkN/1VfCA38ynZmoggD3z7 EzsROAtxOEHxzkYdHcj09EAkeLQYkdka9kQk7CD++LiN1wjR6UMWT+tIS8pUP6TUEeaPTh1RS4ya qZE6SlDxM6JJSvpKWxOIMMd2ImKuesGjpb8aDp0mbmTadzbZmmiuWM2d7MzWz7OiN+fo9deMJiR2 jO95WrI10ckCpAf7PpIMumRrKjeCoWjaTfQBkciNENGkIYK4fySMTL8RiZw/cWjuJ9udo85cYyIP SYhOE3G5WhuNiPGasjVCVGxzjkPUYm+N4mKVOppAM2snm6LsInxI1pHtR4fg+DxH/NW4R0sgKkh5 8jkyBt3fiIStya/m3zXirLM/kq1JRNmdbEcO+zzZ0dakjjBZl3k3/Wb0jramvlpbDlEhRILPXwjy XRr29lOP1gfPr1UimrSWGGBiHseX203+vLPJ1iimLS6fvT22eEOKPTWMqFRck7e5NKgs1plvhBGZ D5mdIOLQNCtmWxM6QuYKu7NpR53NHJOtCR3NCq9I5q6x2UWPFiOquN5s35DRz1YcCBJR8yRBtIFp dvGuKUTO+k1HQdmjiXhNnqPhEBEb42zMoyW/2gQnwk427c5QPqT6aSW5t39RWWyIPCQRTW5bAx0d 4qUVuzMqcWhuJ8KFWbCL8xsRz68xovM5QgoMeyBpbZrKQxIiM1pgYzwFTZoVbSJeYx1V1zFuMS1l 2Jt611Rvjc9ECFvjXYfyqy3v+bd4H6m5bInowAUTB07qPRApH1LqqDk/+4iV49FFvKYQOXIXQVom cyNKR3D+NiKahGrCh1SCHCHX8VVp44nKjRDRpF0jQFc8CrefjSxsjTg0zWirP9mx4je7yEMSolJ2 l+pTUEaX8uMjhlnZCQo+JDrsXe3OEH3+UkcZElGj8LorS5aQrSkdQU/eResY/ezGHAgSESbrRtnD YQGRyI0oRBUXTOTz78UbsglbU4ha9ufoiIiK8CE1IveuDRqnbtznLxCdTiMUM0fm5VK2R41sTf20 AxsHXDL5gUjV14ho0qZ8IBQ9EZHrN8RcdiUOTWvRw3N0XuHcXCF6tAiRpTSyu/yJIU7mIQnR+a45 4lsb+YvFA7ETSuoINtvur0a7fA7Ro6V0BLxpe+wsTvmYK8i2phAVh4gzEapvhBGd5whH8ypSazwQ ZdE3IhFBB8LIzDQ4xFy2RORikcbc0JbKZ1sTiIAzdSPik61sTaR9MiKqvAt6Cg6ESkSTJyLw9O0+ 4j01h+g9Jg7N5jaT7MFcaq5QPiQhKt3XICsn61oTtkaIivWM+spxDI7RGe1OUNQRzEGajmLaZ4j5 Nakj5Kzr/cvFNJeORB5SIYK8437X6BUR82sSUcPKcec2xqHqawoRkimM8pXY+kXfCCOyrRsOUaHA rwtbY0QZmZM+R8NNc5egrmrZ6qcVPypM+7L3mAfZGgV+fvfqiYjKYsYgx7ZGMa1Fw+D6Wa8FtQ3x XDYjMhPx87Sd9q8JfkhGVOrXwFxtZdcPE5rdCaK5o9dfG4256reOyNaEjup079papCPxrilEBaui 5/UUCyxd9WhJRNXdkNw2NEXfiNQR+pDW+xUSCH0xZ51G5G3toIttivk1RpQcb822teCNGPkY2xoJ cqspNkEgrSqYYlaUiCY3cQnEIo3fta76IYlD09iGXj9lEwUQvYPgYmVExY9UGW8N8UNW3lPDiCw3 Arx+RjgRO+vkrKjSEU6vjobEg986Yr4RoaN8InLvWiOK+SlyIwpRhTGPE9ERPTY8R8kJiu9acjck TR5oWxOI4P3Z91Gs1PQpciMKUfHniOL+/YqQrQm+kYGVGqskxldEzYrKn4beSBOrnKaYFVVEk9hZ Nyp27H0jEjl/yTOKAwNGykE3pLA1QlQs9nTXCDXESVsjRBb4Ya628FZhxVkndQT9Zvvtj8WDLrh9 pI6qH/JKVMwcIjciEUGK1RDFJ3t/tWhrClHBhjgRQUpbU4hwetVsLZYO+2AOBK2j5t9+Hqhk3mON CBh0zdZiuC5tjQUlVMp+12h1iqplM9FkctSX9q7FZi+b+WRbo5g24UqBbWvUfrZEboQQnfFaWu45 IjZGo0FnWxN9I6k5QTUGxy2Jd4115ImU7BzFbI1FgmxrQkfd62hSmKVq2eqrzem+Wo2OlvQhFaI2 XCwymJRDxGsS0XC2RjXIrmZF5Tny+aMRH8ih+kbUV1vFv2uxKD4EP6QUNPzQaaKi+BJ5SCaazL7X TzF7HYIDgTk0T/8IElGbPj1W/JKwNeZi7ZhU27x+sR22dfGuEaJiI3QgqHKXhg2mkK2xjorr87dX JJJyyNwI6+gUlJwPSYtK9mButDX11UZztpaJJeYQff7qq/Xh3jWagp6Ci1XqKBV3HzEHgspDKkQL P7+w/il4j6WOin/XiHGgi12HUpDrYm24HPbjdbLJ1kRM2/Ac2QLd6GcrH5I5NK12BNbfOMc2xU4o RnT6kK6VweiKKaWhbE3kRhylsxv4fQiq4l1TOsJtsGPyCmc7sGxrpKPqpg5tfDEWxTdhKdmaQIT9 2WPidtBvRCJeU19tYYGlM5XKHhciW1PZGljkdp6jHn+a9CEZ0XmycYTBKAvVwADZmsiNgPdp2ZoS R2H6FLVsFlRwiGaTBNFy8q7eNcHKkNE/6ryFoStuH8XqWWBa7ER0UCvDEL3HzMXaN8fBU1BHHtxL kOKHZET2QC4niKKjVkUeUuoI/prpKB7Irrh9lI4qerVLtOervhGFqGD3Yedd0DujRbYmsjUYihpJ EI/Bin5IxcUKa2AMUY2efx+i91ghmrjEde5xNdYR2ZrQUZoOERXFta2JvhHcKW6kZVSom+JdY6LJ 02iTy9U6X/RZhYi2xhyaBdvod3mVqJ2q6IdkLlbbT+umV0XfiKivMRfrci3DdmdTvLZEjxbr6HQ/ kruzaczDyvhka0pHFUdh8pd7ja7mCvGuqa8Go+GGaHD2WPQeK0TIMjyukT6PqDEXq0bk/aMjJjRl zl8hwg3ew6ago601wYHAiCpC+ByLu+r7FPU1JQg7xk9ERA68x4XI1tS8CL79i7lYt/WTrVFMa2QK r7923tkzfn4kv7tHVBpC2FPQcehUcbEyInsgsbpuQ/A/OKPdCYrNp5CqH7b7Lvy0rni0lI6wKnp+ tULhuuJAUPSgI3tEZGtD2Zro0ljYfLpwE+/Hx+27phDhXtGxuD0fa0fFCYp+dneIJhNNKlsTiGDd ovnZg2qQKg8plQ3Np/bS0oD3ZFtrTDSZXcvwqSPqiDL3JNpaU6yebtHtKYhybIt9SEZkeUjPfdgi 15iZULQ1RmS2lpzRHjEzqrh9hI6Ko8Cw+yh2Q5vgaGtSRwtJ79deJOh1NDnnLxFB9XJ/NaqvDc6N SEQD5yDXrqcwomBrGtFw1k8tel3MikpEsCrH7iNYWvXxurODrUlEBTvGF/ced9h50O4FVU/ttHie VvWNNMWhmbG6PjeHa0DEuZGmODSL/2qUiVB9I4zI3jXPMtxitsYuB7Y1yo20PXoHgiY3oPC7JnXU pn/7OV7jmRqpIxjH2P4RtQyLvpEbRPBA2nNEUTa/axJR9XQzXDta/K5pRMXZWuf8Eb9rEhFO0586 Ovgcce+xRFST01Gm6rq0NRJUsbvrosCItrY4XmuKaLIP79XG5wjrIocTFM8RlqAX+u/fiDheY0Rn vFYxEXX+kUdhOF5jRKW5RqZNDf4RBIm9olJHNbt3jauik3MjWkfQpWF3dmTQHWKHr0Q0lrN+aojb 0RHZmppgqT7HRsWDyfGaROQ6fSeSfYCOyNYUAwryHy1sbPlGxD6kQNTcplPL1cY7eyTeCaUFLXey F3VpLO49bopocmBuxHi0ohORODfSmEOz7UalJ6K5V4g7QfPgeI0Rlelo+I2xktKHQ7xrhOg02ubz R52ISxrn/IWOzKt1nn+nNsbE+9eEjjqyuWxbi7kRVV+TX60u99XEvAjn/OVXA265bWtR0K5CRFuT 5whjkfnlPtqlI/GuSUTZISq8EJDraxJRCnURciJELVsKgkVZO8NOc0dQqfk2kXT9G0/2V4Wr9dMu yKijMl70oOkHQcgGegpKNOZhHXIRUSZBfnePCUoRkS2rj7bGgqx4WVGQJ89/PpABUVWC4G+egg5K HzY1mveGIFrnsMv0AdEUggoMK5uOKFvTJgvahXMnaGDz4fl/SrwN1lqKo6Ad+DhB8wtj4c/UcOLz +6cVErQV6QSl6ko+ybQdLzaYXX/+NKK/yun0Gl5XbR5fLbo1o4sDyUNezXGM14O7faZAJO/smp3R Un1tNw7En2anxOuodGjSOlXW/fD65/c2D9tDUU7fqR51lTbS3/3pj3/+f/7P//iHf/7LP/zz//w/ /vz//Gv++tu//u0/4n/jOP/pvdr/m0Y78P89/ylHTuVP55E/H7mecmt/OlLuOf/p4/iPABP/+e9/ /duf/+Xj409/+W9//i8//fd++7//b/rP3/1f//jX//5Pf/vrx//53/7lP308TsPf/fmf/ut//kv6 3P9P/vj8p3/8y2nl//ef//Xv/+G/mLI+Pv+y7f7v//7xF/7ejg/++T//41/+8V/+6z/wQ05PwvWf TJz/2pfQdnHC/TnXjUD0nr4FVky7msDh0vAf3z2KD4HZCWSEIbNsb1c94g0/YUPC7whdztsEugTf hXC82jHvXY/r6W/IL7T/G6fTFn2Z2l9t4sP9dfeYPQRW7OwwHfYaf/JewCIR4k9+Ipzuo+TT/8xB YO3lBiEK/EaYV/jKfpHCRnhwy8b9OezL6TCFQYvrHc83AtVXHnV5gZla7nenfIaf+uM5LCRwxq88 gQPid4S+Vc7OIdM3WVtw9wj52FyeowsVt/twfpRoerW9Iuru/ro62G7zw3UOyZNN+QYh/uT5ELim 02HZeALC2m4QqoNdWrCUxuPCx6sS8R383Z9Dx+e5v7L7xdex6TcC5TmMt02myBsFdidQnkPncJ8C 04qmN8trluR3hGXG+9Cd66tv4lU7uT823wj9DLGdQ4o2bQvPN8Lm/jof7Lo5el5/e+29IUFgBYbr +2PzRJjdTy77sgoI88cNQj7Y1S82MoRFIwzB4w/nsIaPcqwY1iI7uBcoz2EP15dPkcfqz30wef0n 4/w97rY5Qnv8leXghsQ7hOPrGNULzCvashpuYYRX3Gpby5xv03EN8UPgpmwLCDnsfSJM4ScfNJ3e F5cH+Ce/ELrb5kRY40fZC9IkQqnDHBBWyj3sksrDUu5N73VskIjNLgd+l28F6nM4vEDfWPt8lx8C 3/AcjuAfdr5gYavPbwjXTs36n+yO4b5g64sJ+RshH5tH2iO5JMlnmiEbvD9KeuWVi//rdLDT1Tfy Epg391hACDsIPEL8yU+EBcl/T4QrE8Ij3yDkg21hREeB5csn5S5n6dVo9NurF7Y1XIj52NwJlFGA D3wi5+HlcLL3dY+wHuFgN95UUtj7+uEcuuSzIaz8lRt5sCLZdmXN1nl/wTnM8yslumBHZw+Wkm6P /4mym6BfCFfgH30muiVC95Ov/4mJK8c3woMeKex18AjFwT4dTGfLttAkOksDVhF8Bz7/pnNIvg3M zXqB8hyOcA59++PzXX4I/N1SakRYqXvVyvffB/s3hMvvft0/mVziWV9J3ydCztVe1Er+3H3WSF23 v3J/sXwk99flwUbmS/sf6HywYVLTI3Th7RNh8whLo3MIPP8eoTjYy8XHG2GOX3mTLTwe+vuawOsZ DR5sp9vGgrUo8M63Mc+jo8DTtxnxgt2PVMg53CFMF/8gIhzU2bkv2CDwDuH0lrZfQSapho6q3/zD gbNr+793hmYUjc5JAu/e5RF9mxJmxp4Fm1/flG//cDUnsIfh6qu41UjgHcKFw3Hf9yM9ozm/cWyu /4mFO2weNzgjtH048aPcvSnJbUC0ClOf5M7lRrHerfdlDORQaEzhob4O9vgggbcIjUYQbfkQ73Jf 7xybx/+EDS0BwmzZtY8oUNjy7X3Y3arFz5zPZ5VivYPbc28R+mZaQzjJx1a99T/c2AV3X+W+69gB oTiHt29KcmxK1smRKDQzVpookMt3D4HNsSpZR8do0XOw2nz0sX949TI+UiX2hFxxyiKBdwiNKA+C PStYVkr3Teh6u/8o1/+ELX9zXEcH9jB967DywebK5SWwWo03O4GTi7MlkX94h7AWbBi7OjSo2N+B /Oh5wd4gbANnmPbI0GLva5U3js31P9EdK6/9pwfzYPbCrsidwGX9qBjrncZNy9j3RPOvlfLXfbj8 BVvpcti7i3+v4X9fDtn5NnEs/XnB/opwXe9gdxWez1xw2+pD4J7h//VyeAi0cwg/OR+4uv0b4eIm gcU+9jNOSXh9xaGV68ZuhPBWoDUMDSfwoCegib4a/snPCxbTe3b7+E1F10d554J9vinu2NhH4TSL ODZC4EX6WNyCob3KZNCbIkzvTuB5Dg98pDbXbvzKdYnGC6J8fMXL2H5zPlKdEpIj8bt8K7C7iX17 l+ei+zC9YynpGuwzNjr/kzuZ3njL+7oE2ruMeezStifjBbYqvjKN9d3kHHog4rvV4Z3A7na/2zFK dGx2u9+vDT8PHXZXrY2v4MfjPmQd3gq0Vxc/iqr4dNGSxD/58dAXt9PLHvrEzZtVfOUbgeYPIsIz vOUbe88T/qrDXZu3Fc2YZt78a1T+mJ1DszuBdjlgyrS0MIWzddgEQlpF+tBhdRnNz5rCK3rpUPjY NwJPhNge9mm9WT3eNrtG/7sOvxF2qJKZr1PZUkRYcScwu7WglwfL9ZS3WuPyHpA/fepZ8SefKmjk cM53LOUSuMMIFLhEW4J69TIN7D91iA2SNqJeyfua4tW7E5gbElJeYQWnWTq/KaK9cC+kPk0NOTLM Re5U9Ldg7XcdXgKzzYOADo2Pi3MOhW/sQguyXzp0P3m5cPdbh+zb3AnMzbVR73NINXrlH7JLfC34 sP1Jbkl5wr0TT4R8Du8EFsvOwQVrcylcXMiMUCwcucKKuuvbL4SnKRL/7Cxsy3cCz+uqYf+2NYJz hvPgV0/85E3iZPwmWKAxVqJM92Hir3wncKdI4WDbwncuFBbunxWkUpcO29c6EKGZHt02maOAO4HV 8Z5cY2vUptWF5yA6fC+EZwCO96GtOqRE0B6E+1WHz3gZDWPHy1R53Kn73xHutVMteLC2II66+3BR wG8Ca0PykIuGhHNfmaPRxmuwvnVY3FdegfrnOof8Lt8JPHW48ILth28Eu3RY37ltdifR3mCIvo0t IqR3ea/s+V2HW+DpKTSXczivM84siRu7CRbHh6Xg1sc9/0Sr6SZ0YvwmcOsQaQKOQMhzncN3WtjX FQodBZdSf6Yz3m2RIRwXMf0mcNZdIHoJPP8HMm0GFzf24tDs+p84+l7c/EI4zwsypFn2Il2K6LXA Vd3O8/M/FaxGU0UB/JMvN/6ouHLs/G8cIXq8OYd3Amc/NRR0OGmvSWFbXhyaPXToWSU3QiKWW3xj 3wmc8ys0J0+xK0/FyzxK8fhPrAhVXgItgI6kRUtUfO4EngjX4XTYxB6mKuZYhMDTW/pMZ7Q43Veu cUtE2nf6OwhN4DrOdxnTfZZdo5nWIfKHFx6pQySQMoTE9611qAWaDnGZjZkice1NEY2qn3z+7+6x mYy2nNduYQ865MT4ncC1HEnS/sklcu7bR2eEG4/QoXFDVCcw+YWrJ8JD3YdaoH3l5HR4hgXx1bPb 5+/2TG1aeZ0O6vnstN7/GBb6/+Kf//EPf/2HP//tP3T855f5nzxaOWD+p9r8Ty35j/mf/xX/xPkf Ow1i/Cftf2c/BGTjPvbfh+mf/cfn8E+4NQ74t89Xfh34Gq6vFFeSrMWuN4pzrS5z55qf4nyR5CFO 3Lr4b0Q3HYFKErPPa7BTi+ICOtgBcv32iG680CUhLqCDfsGdOI/sPrbJ5mYyW6KD1Re79PADumdW CP4d0A0/XUtrS6xv4ydx8cs2J67k4MouoOjLQlxE589diXRmq7+YI99BVx26HP3iJXJ+Bf4d0VV3 7nJ8640Z+CdxER1wJW10pLuXuPI7OlwebkYyont4vLoS3kCHtKLbyD5Q3LFJ9SjHAv8O6JDF3W4U +hSVnVcUF9DB8N/VvRmc621kB4j5Cd3pFAEd4zbh+GVrYYLIH9D57tcjkugv1XEC/466wx97xosu Xb/FiUQI/DuiA1aM3Vobr08Q14S4qDvfId5IXH3teXgDHVKRybdC3Hcd/h10l/DcuVP9LY7fChT3 07mbm8nWi5svdF2Ic3nw5Ehcsu0mi1YxX8Tt76Bb7stWfrb53A34dzx34Uahh1F0pqK4iK573cUE 4YK1UkOIc7o73BbP3bpBXsCLsvANdBVTFBN3PHyj44My4d++WnmGqi8vwJoiYooaLyglznUfn+Ka FxeJ1WxpHOVP4N8B3QG0WLkwSacVln8SF9Ahe+TuAIkHBcQlIS6gK8BDbuIiN/L+sTH79AO6Ppy4 SN+xmugZOuDf4ctmL46ebZlCeP07oKsl/SJukQf1Ezq43E0cHWPYI/0GOvBxtrjIeWlsr/RjE/w7 oFteXMweq2OM4sgqPpy4yDOPRlaEuHCj4AVlnaORKXQflOBB/YCuFPcpciSysWecO3Dw3/6+K+6t 6JE4bhXV+vb6t0N3IHnx/rFxP8+CPrUqxMW34lVqNekt0v9MQWd/iy7hFsTdl8I3ijgoBf4dvixw wO4vS8dYfAoQF3TnLvcUCuHh3DUhjnQHP/aUTjZ7JPKgbtGlTUeEuouM8OpyTxX+HXQHPMw5MbHT Uq2/IC7qDtLY+1PQl2UP6hZddlTK+/qk+26RB3WLLuFU/u7DSyROGFmDfwfdNX+jRIbWVUWmAsRF mz3cpyhxVeiqH+RB3aI7dRdeMvJR+gd5ULfoEo7d7HNHt7EI8R4jLtT/aujwRil7nsWLa5WGhH4Q 17LzUar8sRIdR4y5YmObiVu+sHpG29afJNEJcQXnGfe567EucbCRXaMtPOBiVQN0F2PD6w4EeNro Vlz7wllJ69vxlLW6JvEYVeIfe3wd1V+fcaPbfnokOiHO+Yf7y7BvLEK8+vq3E9fPLwfnbgSaov3O dhoKuhNXDpyLt57PGiufS9RmH4L4GNvCYtBdZ5LN1e7QCXGOXW+3a1KIp97ZR5dw7EkqB7IC2I+l dtQ1ebroVtw4b3PQnZGwxh87xNOzBfExPtFBy7H9MZTWrsW3Gp0QN7Cbwv4YdnikzQqh+/VE197Y sf73H+v5t0l3Nt328D7zL+KsBwliMluB4on4T/nlbnJMHOOODNzWCFKi92nK0OhY3KblfomzXQ9k s0v0pVxtLdQ/YzzzfjNDiay6O3gPwz934qxI+hp6Pf+43MhXzFR4dGK85gxTYCNKL8yKvq1ComNx 0yY7Xz92Wh7EibPb+K7bgw/KmrjhdbcBDDf9avXhV+9b/0Vcst2j7fXHkb2VfXufmuTt+v/39x3u /s11N0D5Hwvc5EmIcz5K2Y3NT3ElOrNms6+mjCCOo21b4QfiMvfJrDZ/FBciRly/aE5BbAza0XY4 KI+rSekOWdTt6RjqggqUCSjOoavInm1/9HM++1MwL+837weh8xT/1s5Ct3HjtSwoLnzZgjmoUxw5 Fa0SmdbjamLdnTcATkmNwC34XbJ8+ChFiHPoFk6d7j9S7nMt4g57iGPdDbfsO1vpiOLZ9qM4h25i UXGLi/todhCln23Sne3uAJpb279DeRSx0xzFxdWNsFXAqG8pPBaLgB7iSHc2MTIcOlpMjD9WiQvL E3CC0MRxLmASadHj4iTd2SpX4Ie3PxK6tYiyCMXFBdNA7r4XxUbP/eODOJoe4kh3tmUcSpa2CJly UPNncWFFOEaMtqA5rjBYk0kEHw8j6c42OuNCVVtF5G7jtNe/R5odFIfobEsgVN7PPw7yjdciXqGH ONKd7QqEePb8Yx4K3Q/iHDojCslO3FKXeySHudrMSHer7WrJ84+n90jHGH7sEOJcNWUMyC2cf1w+ L/N9BUQunEe7aESXxmlWz7//maZ16EeHLP0ozqOzYcOXuBPdxNrR97mjwZj9b84b101n9/xjw03D D3FyLOZWXMYQz/dcP8TdTWELccaDBj7KwmoI6E4GoFLcxNSCeiumaA3uWpx1tUJPRTGG3I8gTuju VlxGVk77I43r7B8rx2iFuOaMrHTHGPK673QAKsVBc6eJi03LW5wcQxbi5j6mzz+uL6IiWmLo7gdx fRYUVxuFKQLd7tFmcTW7fpRa3DaG1xUQ0d2Lw43ip7iD6mSLreIxhsriQrQ9eUP1vu9iePyDOLjc q5GMfERxd2OzLM6GsGABjq1BntG/E8XoH8Q1eBibqggsdd/pg9LWV8fUwtp7gUHcXTrwVhy28zXr nI9xhRi+2swPQpxF27hhp/CuFhW834pLSFpr0tkLmNzO95gfZHHTfYq9tYk8KLbZH8Rh7+Je3BfF rbvVFCzO9odm56M4hrfrU9wNNElxC26UYUZCPop6yfRBWTZj9vrLy+r6MXgv/GV/EIebk5ctzo7n rvCX3U6cEJfS2DN9zz/WM6gqQRyjuxe3gCNsi3NceCauMrrdGabEFUsGvNCV6nhFnp/ieF/ca7Zj i1s1/Fi1fmg7ZELcqfwXg8b5x/JFfZ9LvGQ/iYP8nY1cxRzUkmQahxa3YEXW+UciJL6SRuwF3It7 3lDnH8+A1jMwS6tINuOlHLKcoFl7/zFuXF2CHOBe3AH37/6jy8t8X+4RnbWyKnFnjPfaB3w6swt9 5Yc44QXcisMx+UvciufOxJnXmGcpvZRjnfF8/t9mmMVa9v+D17/8PP9xurjjyK/5j1L2/Ec//pj/ +F/xD89/vLP+5Rr1cHtf9h//+te//iNf68dHNKziyLI/C/ZpXWZ1O+/hsmFnmN68mHB3qFlehQZp CotjYbguSEEMpNDgPHXZy9X8XfF6VJITE9BgO3fx4f3+UeIxEWgwQ2N/nEGMYC7jGYl2BtwgpuI8 xxaThIfGsxHmSy0U01sKYl6Php/bcIHPV63u3PTDf6kMpHv3aIojtrSlhCO816LFqAg0C8mBQsFj 96CxF1EIjRCTbsUUJ8ajwcmf/cfhxGDK/x5NcUOvW4zPVQ3RzcUtJg0bQ43Wt60gRhRcebah4crx LebwYia4Qn7uInwpR8bgSUY+H8Ract4inhvkCcJ4Y4vpXbBsKN18wF/rYXPAY2e9FBN0c3gVY29G ULGfq/C6meDp224ct0LEVLxu5im8brDJ0XTT/PHrnY2BZxSaC4vOHxVnT4YwTZ5NMDHLialBN6Lr j9GcQRW26Tc/Dff5mLaW8xJBN2jR3ddtP489wqcHG8Ipzu4Ur4BmiKYtnj2oblGy7eqowTQ/uKtP oXGcLm6H9qWb3G/mIYJu8K8NHLO4dCPODbdlNbdW6xTjKHA+HxtbpJhwbpB0apxPur+Lu/AoeKag uQ44E7P8y9AFMQHPEpiY5cV8BDGLPApG0wPz9HG6EM2Jycyh8isaEwP0Lp/HXuF3M4gQdAMWPr8O +E0bjWrxp6qKiXl9GiNRX/VWTJhjcLqpfkduCwmtDou2f0ZTUIyj2TLdCE4/ngk4xWAfwPmjQiNQ byIvQbMAze2dNzE53sWJPApG092Onb0SAtdsHHsxiJ5PCGgck/pp0vhSHJtI826QwOkGWa6mb5H4 fGwOlmICmuKOXx3h3IAnGucQEA2+/Ua5H92kwTTkjGac19aPP2qKUUvu6W/Y8rXFlOCYCIIy7uVn Fbd+KybMGXjdOGbn5F6Yzwdzq5wvcKtTTtN0XCKOXu/ug3PzX/xRPQVjUBkh6tVvONOxxXx83IoJ cwTOppyvt85Xs7IYOT8QdFP9XYyNuVvMbaO/082Bke/5o4JH0QRtHPfi2+pzp+I5/LXVoG82zAk4 3eAmy725KPmLorJHwWjMEUbd5FM3/viJPlm5qxx3rxjXQLDweddx739UwoUAe3uS101l01QLzx2z raX7szeGI930sPsf5TiObGfE4XRT3tozspdZQBfnwOmurZs077rCUUxDzuPdihBMU3CXC87ogXSr u6W+OsdkL/G56QK/HxTom/MVf5R4fAWnbMXzZ1SFOfHt93g1862YUh39Q5turaGJeWsdgPV5Q118 ra/pxdi7cdcL7Pq7i6OyMi78DGKqmHkQjG8Nn9vzwxWkerEf1dJN768fYWvQznQa/3IjbdZC3O56 fp0xDLz99kYC96V6rm+scz7d8u6fuxXeqZLvmnIdGow17GVoISvQ78QENFhBXhwkdl50wRfFcjt7 N3uIN4a9b1f28rq1pF/TLWw5cFJon5v6cdd0624/3K9rt9+o3hj6uBHj0WBObItZwaHlBbjy2oII 2nqBkdpzxwzpplfX9YXZPlrXyOWCxgf1eVFiwl3sqoNj530QzboT4xeE4XifiZnF/6jFDCdicZkf tbCFOtN98AU94KHb1Vk4pq+tA/kIpgnb9+7RGB8HDvZ21+zx+VgzqJtlfScVjNwaDylud/52k2ST bGjeRWqA1k4/yenGEv833axhGPCVFLVmoONwYqyCqsXQl3r9tWo7rN21td8p3QzrXwbYqnz+n/pX d8ev1rsmWOdCduz/OsUk18zxWAuvu1XDlBR00U4jPXqC2WLyuBHjvpRRzAMtzJH2YoOXmAL9nz+8 U5vX8/XhkmuD2OdG7D+8Rl3c/sMFnc/n/yk5GizLXt92o+KVfsZhrzv9tPCE61r3ffNxIwbRrAMj qFPM1cEexMSLgp47i1FdHL4O/07tUeXotNFzd/olzb2abqfadzIzXhTi8cWI+dNvrfn4rjOEB0Y9 vhV3J1iKzIuxbdrfYroTE519H09lf4oX7Nq7R2NFFzDFJdJALzfJr9/0upnNx1PBL97pw8e5uXdM LBDyIev0d7H5Ld/v1E9fauGlaWuWm7uLO6w3L05M+FIuuZAZzesuvtfN3PzTKGYd3vcbr674dium u/0Q+0cVf6VD0e1bN5mSmQOJD/eWxeGT4HYZ0m48Smae0Vx3YmbImNj/YrQphQZXeRqaloIYnt9S aDALdS2dDo5JJptSaPpwxjAdx/1j2XewKYVmuB3aF289ioGBvuHExDjc+8VYnrcHZiWyKfmllj9+ qbo4fAeJwaakbqo3hhZ8v/RBNiXR4F1svVzT2VSpg2yK0ZjrhzmK5FgxvkPWYFNSxZ4s+XRovbcF aaCnbsi9Np5DXzxJ+FLYKsHMNiUSdg2dNNtKi4VtQ8MOLaMJiZadS/fO/lxsU4Rm4Fj/vm9GSB8a 50C0qTd0k32id4IL+ROaw/G1p1hY6lXYlEBT3bkxTrQPFINOW3JiAhqsh+dEpmnhfLQpgSYHVsbe nYqt7kQ2pb4U3naGZrj7xtwfsimBJmFFKPt9GSamd7YpdfwwmjMGQR/OF+g5fupmCjR4+9klmvwl 2pi86RLjw3ncWbRX9vp4ym54simBpmA0d4pJ4WVo7PsxmuEIt/ZdXHw8tSbblECDo3CXMbiLYpTM NkVorIfY62ZOZ5pjZLYp+aXgrxnTixdTSmebEl/KLRy0NeQ+J2ruD9mUQOOWBRkjkT83ZQqbUrrJ +KXW7mlCNJZpizZFaJb3/fK1BsiJmWxTQkwaHs0szYth308sJz82BdDzj/UrzBh24fupFJlbXmlb WT2aXeQPNiUTdmG5a/MPzK56BGPQPwqzAvUrFvkHPzDqR7kiv60vD85+LmQMKifqWijNMQkf3FoO gjEoNMmd4sN7psfeCBiNQaFxbYJG+9t9MvNYZAwKjeuZtVPss9c7YxKMQeaLh38ZsOPKxBR+YNS5 ycEvXqFcsYQxUDzlicH3KQ5h2dHYGChItFsTxqcs7+ufu1ETGwOhSQc2w+3Vodn7fl0QWRCa6cjT 94/qTszuMYk2pXSDO4PtR4VYc3JyQegmfx0opsfq/BBOm0LjWiqNtnK5c2OUTGRTjOZwo2TmmExn UxWS4D+dGxwa3eXRIAYck+LEhHPTkbskRTHYAHGvm1TQF9gUdc29mjvtHG2KxSRP35H88vJHWT32 0FI8daKp4YP76G73+8UeWgoS04EbT00Mbvbd2SRm1xBoDseFY8u/Qy5dJBckGtfO3lzrwo6nOBCS uinTWfjwLU7zYKdNoqnIgt/x+vn47r8JNqXRgCuwKerC8WOnTaLBjKzFDMOhsT71aFMSzYGlnLSD S/xRcBcXJybexeiJZteYvt9wTtgJNNkxT2xOYP9qNn6n5PGrSKKa8Y+X0yZsStXuGlQ57IN7NEMk wauq3SX0/bobVf18dDtHm2I0aVe8QUz1b7jN0pFNMZrDlUeTZ9AJz113YqJuqhMTKolDJBe0bl4e zr62/AOzG8qjTUk0MCOfm1//bQ8MJxcEmoQ63cbw8YFidvEk2hSjKbg1xo7f8IFQG5wEl2hgG/VG 4z94E8kFqZuJBMX5K8zB7Op8tClZyEa+WXMwvH8jAqFK8VRqrqckDVz5uO9iwQlZKUi07jN//JpP rdqzRTbFaEyn7mVYPoDGByY7MdGjgHNj79R0usFcendiom6W003zz91uN402pdDABMN+7rK7/VQS /AaNe6e6z231JN4phSYhda+xsPh3yj54tClGk3FIaBuDv7asmEY2xWjy7oVCNCEss96kaFMKTfdr BKp/NS0sJptSxy/5d2p6p61O7nZuHIdnv5V0xtzWOCrZVKNY01zIA07xaZrNOSbGfRttSqBJGMKY mB6iu8q+n0CT8Njud8qnOoweLNqU1s3hdBOMwWi9ok1J3fTg0Ibnbi6yKYmmw1ZMW23vry31Tgk0 GXcSbTrs4CaJd0qicezG+SsU3VrmhJ1Gg3zVRs4dxLDvJ9DYq+nErGhTlWxK/qigm5G8mMy+X+Ow rO4NWc8/Tr9n3CcXDicmvgyYPhx+JvrYDFdkUypIhNzqtvDpxWRu1JNoIEi4LDyg4byfQFOcl26b 2Xwy0xgfyabe0E0Pb3gTNqXQYOkm96/QjmFnhGxKoknu3ITOhW2a0aZkVgBLOUaA69FAw1VxYqJN DXhgqp9EsQbPyjbFaDLmD/cb7q+tnVqNNqWOX/crgpY/N+qd6irWXOBC2r7BxVd6sKnOseZp0rg7 auw4DMUMfqcEmjNmwLzfjIWlvriwJNCcNrXcy9BD6bgssimpG2j9vqoe/oE52KYEmvrlNk0PXwU5 NkNKtKkbNPBODXSTr+w159Lll3L+jecZ+jaGYFP63CBh7nmKQ7dzZ5uSaFp3YpL/Uq1zPCXQ9NPC nV88wyVqLmSwKSHGU8/aReGHNDos8HnqhsOygSPZu3bnT7GNt5BNcaxpRBYQT023zvJTNxXpbufp xHRfyMZ5zezE0O0HF4VRj/mMSeJ3SuoGI5hNouVjzcW5dN0JjtfW/DpmcAU625T8UpgVGPj9rw8+ 2KaUbgLz9hrOobVECNkUo7EqW0Ixh09KGTU62RSjaW4VQA4jsscmTyCbUmjwYjjFHMFLr5xLF2IK 1kcvtlT/ambuku8clp1ocC3R8VV8C7dq1OscaxbscdqrOn3/jV3NZFMqSBzdnWKY9blUPNmmVOTr +kTnZu9DMUu8U1I3EPkmG5F0upkHN+oJNO7yvfaO+vtG5P0kGmzZztPz4VimjX0/+aUwgDau/BXO zWKbYjQV26Q3x3547ibnKKRusInRgkRvDKo+JdE03DfV6fFtnPeTYrJPrU7fYdcaN5QPDssa7lj6 3MtOvU0VbtQbKg7Pfil092GZmjwRaJJb12KDT75PtE3OpQs0Nkzm93EH08zcVKR1g4neI05z2ThV tCmpm+bRjPD4zkE2JdEUfBn8atadXGhkUxJNx42H3XO+PMKyYFMCTUVK/r3j6AXmMga2KYGmuhpM 7m5fxedjmivYlEQD7YZbjH81m3inhJiC/aVmUyMEiZmbX4fKUXRfOp6hM3NwPDU41mw+uWCN6T5f PLipSKKB5sfdKeWnAIfIUQg053MHuyi3hYfnjn0/iQafO7tv4sDcB9uU0k3zIev0peMxOZ7SaPD2 Oz1R/2rWxUMaAk3FBpzr3ITyKDe/6nODFaHuqNG2GK75St0kRNNjNskmZsmmGI1r6d02FfPFi22K xXQcEtq+n5/X7I3XjEwOy1z/164zeI/C5i6jTU0Vh2Nvkj0wfuxzlEo2JdBU5IrZnqg3TXTashMT z011r+bwrsDInEuXumlY9Ug7X4i6aez7CTQNCwvXelj/3AHT8nBiwrlBivrsV9fv+hTn0qVuqneT hs/77VJOsCmJBsf37BRnf99UjqcEGps1yihmBI9C5P0Emo6sGvvV9EnwTc4SbEoev4p7gXvsS2+N cxRTRXfdLwNtodu5cM13qlizZXduZvEPTGXfT6Ap2O26mxhDv19l30+gqXiHXxYeEnbc76d145d9 hrGIHQhFm1K6caHHQY9v53dKokH6/bzil9opsmhTSjezuVRHDjFD5RyFQOMin50xyeGB4byf1A0m Wmzo3Z+bLSbalNQNnuLheAJ3BZrrU/pHoWMyqFwxuY9icljmVgZZ+jCFIr/oTZoq1izDPXe1ulO8 yRKiTTGaAit5tpgWQo/CuXSBxoou8MEtQ+cv0SbeKaWbgmgysI5fumnCppRueoNLNEWmIuuHIJtS aDCaK8cXXDeXTXEPrUaD1A0z9vvZ7giyKZUx6d2d4hYqiQf3Jgk0531TXZB4RPK5yTYl0WB0N93W 6e84PNqUylEMfBnmLo853XDNd3FY1nHMeBfdgie6uI9icaxpM7FuEWTys2Vjct5Posl4iebYC2k/ OdqUQFP845tw89jlCgyyKYkGyxN7P7h/7hL7flo33jSTt6mxuDdJosF1bLZbOMThIkch0FgyE3Rj c3i+PCp6aLVu4LjZ8Ru/vlNaN4d7NUMn+CY8CjYl0DgmgX1RhGa0g30/IWaeBwXEDOq9HjxMuCgs y6H9qzi2hE/d77c41hwu7WwupG8OGY2JaxiNny3aHS++4Ur10Ao0dm6cmBSyAsqmlG5cucIvOrmp T0k0azr3OgTQSE01nBiH5kDCm2v9tz9+k/v9JJoK3GO2Ys539LbOvp/4UkYBAGKMCdRHMIt7kwSa 8xTjG76+jtBjUtn3k2hacTa1RnAF2PeTxw+zSYYmZEy6YDc9DoEGs0kVa7dXDYbfqUtMsCk8buYm efda9aULNCGbVJCn71nXDDYl0HQcgt6nOGRMMuf9tG6wi+x8w/2I2tZNsCmpG7dB2H5UmIEW5CwK DRayi7Vx+aRU5j4KiQb4JPfu+ub9m87zUwLN3AWJ549acT68FyaSkF9qJScmdPTudoxIzqLQJEhK nT8qBd0Ab1K7F3N6sLhH8Ygddk28U/sRYDSvv2ZdHbFYKxiDt5hoU777MOYosmBGYzQViUy2GH+K Nx8F2RShqV9u7LNE93p/cLIpoZuMcXiN81M7f0M2JXSDQxlbN97CE/dR6C8Fz13Je+k7iGldEB5p NHBuzE/xYirHUxoNRDD7FHsVH1nYlEBTYTFrsYcpWDjHUzdonE3NkLCbPPQuxAznmJhuQsakqndq MpoDK4nGZxzYeMQi8S0mvOETxiL2c+cDoSFICxnNcJMnu/3rw4lJXJ8SaKrPUVQ8RtcH5z4KqRvY crInlnzaeRzcly7QrL35D9CE9i+rpbFNqS8FOdFSPA27r2smJyacYsxRnOfm6MH3UzYl0LTDHb8S GiAWz/lK3aTDvZozMqN9CJuKaPLhuA7L4VawfKeByKboR63oXvcQ3VWuTyWiULQEMfYXN7etetdg hE0RhaKpGB5fe+6mN02RS2c0+xLtKAZs4fLSedZDoDnFlIRisucTHaLmq3UD01xWkAwz0I17aKVu +nBoRkh1NK5PCTQJ6+h7uXXwtmZlm1Jo0nQu5AqUH517kyQaSJ5vT9Q/MNgrUJyYYFMQv5uYNoJD K94pRmPBZUIxy3sUdozIpvj4TWzj2Au/Y0cv91Eke6AjGheWdbfGfCfseNbjEhN0M3C5esOp8+su 5r50RpMcQfruIvMjaui0ZScm2FSqDg1M11zHrwmbErqp+Gp2z4P92KRBNhXRWOV6OjSxBLi4N+kG zUs3xfWXX34x99DKL1WgFfcUU0OZa4h4ir+UESXBKc7xnVK5dKmbBAm7kj2592PnCdmUQLOW080R W3F5dl6qGDulTEz8UeKdyjEsy54BwnpMfB/FWMKmMsWaE/svdmem/+AjcS6d0WwalYJiZsjsJ5Gj YDSOYmZ3O4em6SLeKaWbOdw7VeMwoYinGM36qsldW2Dgz7As2pRCAysQbLNBTEot8U5JNHBRFOuU C1kBYVMKDTaDlLKH5R0azvsxGjvFh3Nog+9nSQKyKT43yycXKrJ4XRcF5/2kmI4XxRl6NBZDNhXD sv2l3F0cXAFM2B1OjNPNGc4dTgykRC/TVDYlYs3YquLTh4rsktHYc+ebpqMrkLiHVurG1Rm65xc9 9hIAtimhG7zt7EeF4omYn7pBAzbVcCHLs7BENkW6OW0qu3cqtKpIUmb+UguHV+34VV8C3AuAyKbU uYE25RPN8IkXW3LENkW6KbgdadtU+OBL+H4sJuMAw9ZNSLyoHAWvlWnnc+fKXIFkYx0inuLFCgdy JpqYMkI8pYxBpDoccU3fPdtON8ymLH8UDi9bkd8TkCyVXFA/qmAu3fhFg02pB4bQ1O1Af//x/ODF T1fsxmAyBhHOzzVRTOy/GdyoJ9AUl6G1d8rn0vsUSXDWTUKOj40mltWF0ybR+Mc38ND2oYxBJBdg fsbELJ9L37qJxlAoLDvRHO6DB1KfKYY0LjHh3CzshQx8xsce36UHhtDs5hBXD6+Bi+xgchZGY0Gi /1Epqpgb9aRucGLJdBMbg5lETOsGZ1mHY4G/Sy5INPAj7IHxyUzTHNmUQlOhzFX6V/Ipeem0MZp8 hvNwpTfseLr8YvHAKDRQjjcxgf/GCMvJphQazImeYlbIUSQeehdikgtZTTehkL24+TUViqdsVYrr lKo+Dh9iSOMSE3TjJpYmpixifeoezeYwc2X1HjozJw8TMprdKRWaQ0KQKDZpaN28/pr9KH9ubPCR bUroZuB9MyNB/sjinZJo0Gnre2Mz6kYMadyggTh8EPNr56YigSY7Yr4TTfVDqHuHJNkUoUmui8zE hFM8mU1Zo8ECgXURhg8uirUs5mJVADHTG4MiEUuVgkTjzHS9kLFY28U7VSlIzHF6tMfcFje/Mhqr wWApZ0Z2jN5EcoHQWBeZN4YRBuZUwk7qxrd/hS1qe8NctCmpG/REzx/lBxGG2k6j0cDxG3u2yP0o kVxgNBfB0lNM99zyN+8Uo8luWt2OXxgZOUQSnNGcP2q5i2IGcpbFw4QCTUV/+rMsrAg+I99oUyym uM6FE03ImHTB+p8qxVMd6+jW1THCJo3BpMyXmKAbN0rtItgrZhDvFKGxgfDu0LSwULVmYVMigHYk GzZ358WIhnKpGyTmMzRBN5ObX6VuFrKqLLd4/vPBmUk2pb4UfnBrOQlBoninFBqMnwq94TIJzmgq LmgwMSX0iTbRAMFoCrZG7YsiZvbFxieFBvlETzFUZRW+H4vJu6kAdeMzbburg2xKRL7YcmCt/+Eu XjykcYkJull4++VIBrXnw8mmVFkd6wzH6Zh4jyKJeIrQ7GySq93F7TSi+fVGN/BOrTivqYgkpG7c cM+Kid6xRFORQoNjEeddXEJWIIvCEqPJe1j6+69VoxYP9JKiWMtoPI9JmdhSez0wPEwo0SzMUczo iSpyFq0bGNCtafuMDo2yKfGjkJiv0Hx4m6Kw1Cgsa7jLYHd1BFKfIpLgjWJNI+XNKAaaVi+bEk1F hMaSC1BYKhcjvlOxaIAgNJb3w02o6wu6MW6T4FI3yd83vgS4Ny9Hm1K6Wb6nbczwhgubUmhgJs0+ ePYbEbDIn5yYgGbClV4TxVNNvFOMpp4XhTt+ZXLCLtoUozGiLC9mBWMQ8ZRCk6CueYoJ66RxeLnd i8lIv7NtymeTbBCFbYrCMmPHgFOc4mwZBkKHExN0g0Pv1jYYmqa7aCpiNAdWknYXWXhgushREBqz KbxELfEWSoDinVK6OfAUn2h8K+7O35BNCd2M4VUc46kPYVMCDdK91RTpl9oQ7xSjyY5xxo5f4Hjp TMyn0UCrir0M1RuD2vapdLOSs6mwOmUnesmmCE1H3uPrR4VzI3Lp6kc5/2Zt1jAUU9QGXQrLbCe7 OzfD/6ilhjQ6xZoFqexNTNjPsGOGaFOM5qrOgZh2OAvf+eJoU4zmcGzKZuG++3DvrI02pXTTsZST IqfUEgs5pG7wfjHdxNl5HiaUaFp3d/HwOYqRRDyl0EAc9lmvGBXE6A26hOaM7iDWrHRR9CLiKUZj BSl4Ne1XhOQCk7NINDifWQ9u1BPvFIuxDSwVxQTmEPlOdQrLjJgNvtR5i0XyOZH36xRrVszsbjH+ otgpMrIpUVY/fFhWYmpV1HwZzeEdkxTzftZuzjYldOPKo3kv1ETdfIhGPaWbDoPdJUduoCFImfWX gv7i8xRH0kIVTyk0SEFfE2xav1S8RM1XoQH6HTt+zW+Y61nZlMhRANfmNoZwiqdoKlJokG/r/FEz 1KcOEU+xmHrqFH5U4WFCHnrfPTLRwhuGZae37S8KO0VsUyIOb34qZ4TxPZj1uEez5xmchc+YBBfN r4RmiykopoQM7RRDGko3cN72j/LT6jMJ30/ppuK0unF1fKCYPetBNvXLl6r56/hwYnail2xKfSnI bVUbF/ZxuIqnGI1nfq00pKG2Ugs05ymGYq39qEC/JDe9KzTg0J5iwgRBW6L5lcUU13B1iuk+KaXI LndbALmQmD40PyU0zvAytktM0I0bCivYjnPVfJmYT6BJPrpzLSfXuRF5P0JjKXnMCpCF7y6yaFNS N9COYWgCOYtq1JO6wXeq+HX2phvRUC7RQBNjLXFAtw0eehdoClYE9ikO8VQTeT9G09ycrx2/0I4h CGSlbop3IecRHBOR92M0NnUMurHimftRckiDxXTcFLV1E2owWdkUhWUTd1Hufr9QgykinhoUazb8 NCamh3Be5dIZTXKkhdYLGbk6RDzFaA7sWjSbWqF4Ija9S90kf1E037mwSQvJppRumrOpHpZbV1Hz lV8K3CL74CHtrJpfGU0wzYp8JLfvFKMZOAexbSrwiRaRo1C6ma+OK0PzSnw8bErEU4ymIx/Bdd/4 HMUhar4sprkr3cQcwRMVvUlTRXfwI6wzMwzodtGbNCnW9Px+1l8c8sVD5CgYTcIs1EYTvXQRTzGa M4Ba7oHpochfxTuldHMA5Yf17IcNul3kKJRupu92rqEvfYq8n0ST3QfvgbB6iXdKoSnQ1XGe4h44 wcWSG4GmOcqPWmJyQb5TEg2e4rafSRQzRA+tQoM9JrVEcpamGsqViitkaKtVkrnoRjZFYZnRNsHx q7E8KslZJsWaDYsuu7843sUiR8FokmM3NTHeFZA1X0aTfARTI5m3IjqXukGCtW0MPtY8xOCT1E12 puk2v9/4foxmujfcjMFnk/Z9QzYlvxS8DDzroQZ0GU333lb9aonbv8imCM1pU1BWNzGx6iHqU4ym YS7VftQhGsrJppSY4e6btYKFq3dKRL44z1Ba7IW0BBrbFMWaZwCNptloYK4pmyI0eU9IoZjwTlVl U2KCoBX3arawiFeQMgs0lml7/bXS8Nm6LgqR91O66b6FuwZivsYkYvpLweNb2+aEBjGK7FKgabgJ c/t+mbMCZFNCNyO7ByZFMSJHoXRTlzfNaFMi78dojN0S7pvTUgNJauLlAULMcKu2a40cL3sNebSp FcMyq4fCcbPGYJ+FnFX0Ji2KNQcyqu0u+VA8qWKYkNBYxwuWjjsNaSgSMUZzBlCwiPc8xWGJn7Hq kE0p3UwsAfZIriuJJBiNEfNVL4b3h0eb0mhc6LHCIt4pZj0kmo/XX6vGjuHdJMsKRJviLzWxFdPE LG/hO4KJNqXOTUdPdFAFWsVTCg0cFLNw+I2XTYkBXRbTcRGr/ag0fo+nlorDsYvslBqaX7t4pxbF mtPxF+82ZR96DNFDy2iS21lrYmIuXfRRMJqMPKRmUzMWJEUu/Q3d1DD4NEQ8pXSDfemFeQWG6KGV aA53ilO4KA7xTskvhamOgTnxLeZD1KcYzXATS2aa4kuRTRGasZdcgJhWQ3Qn8n4KTcYmxo5Uz09j IJsSYgZkaE/dlPD4Tq5PZeL32yp2EwSH99KVTWUiLbTpQWRiHHEEfxSuTwk0CXNiu9tZjFIHmxJo Ei5G3KNGOdzFbFNaN9jGM7B49tRNsCmpm344FbcedMN5P40G/lod2NN4HT/uo9BosHNh0uKowe+U QDOQVWM/MD5Dq4beNRr4UvajwjrpycvYJBpkVTnFhCrrHmAJNqV/FCYzxxcUoJ/lCrIpEYd3qECX EeNwHNI4nJhw+2Ez2ikmrpURvp9Akx2jntmUv9K7IGUWaNL5KyAr0JG27RkzkE0J3bjkwsCtD5cx cI5C66Z6mwpkUI17kzQaICCpM5YAkYAkOTHhFA/vbZXIC8n9fvrcQMfLiQZS6c/jRzYldJOGQxMW AO2GcrIpQmP8N840h0/Y7dwW2ZQQUyDRW2nXcRfLAzLx+1ljKM56TIoZknqnKNacp3tVnZhw/BqT iDEay1FgX7otxmRXgGxKTRAc7rmDGz2aZndigm5cJ/jEBpiPmz4KqRscCjMxHs0mgSebIjTX/973 HystcsEZoeTExC813Ts14nw4L2MTX8pGTT5QTBgz7wfPegg0yzHO2KsZTrGY9RBoJpI5m5geLFzM etyIcbrpPmbYYqJNMU3gxOEO++Cha3VUJmfJRFpok05YEZpfkFu4YgbxTikKRSwBFnN3/AMj+tIZ zX7uwDTH+U4F3XDNV+sGfsSJZgYC2cpzvlI3xesmoFH1KYkGp47rpK3Ui2u+Gg08d+38cH7nye4E jzal0OCWEUMTODMn9/uJL7VwWvmzrq8cKBQ/mEBWomnZiSm+Ar0dk2hTLOb8e7Dxqdkgwq+zHpn5 /YxGB/ybRcuRwGk7nJigmxKGlwNla+MchUBz2hSo1I5fZPDkfj+BJrml6HZRhNpdF++U0s3yEwSh vV3GU0o3DcsVK0Z3as6X0di1dbhzs0KB4IPnpySaCpdoO+Jk7TYGsimRMengCpxoRqTC4/qUPjdQ Z6g2BchN02RTAg3+tfNHVX+l229kmxIfvELXqukmjNNMJubLTFp4iqnugzc/64FNRYcTE3Sz/Iha 9ztPNjdQtClGU74q5rZSXBq6G4OjTTGajJmWjSbkbxrPekjdODLvtbk2nW6ETRGabQyQ6D0ia9y+ b6JNaTSvU9ysNTLEU9yXrr9UczYVWuP2bFm0KYkGZudPNDXy+wmbkmigV6BlJNi7xHDNl9EYzzqQ Mjfr6gjGIHw/JQYXK5y6AdVc9Snu98vE72c0uDhBcIopDs1MPJOYibTQ0MAMdD2I7LIL30+RFjYc 7sl7jRHqpol4iikUy54Cev7Gha0Dz5iBbErpBv7a+aNyIDoXfRRaN+iYmBjmdiabEmgKZJPMGHwa qFeuT2k0oNKWMCt0+X7cmyTQnCYNX6oVDPauU8w1X4HmcFOA7SKRcmjEO8VobNIJ0FQknr59p6QY 6OhtBxfdmI8iE01gOXzr//mjPj5QDDZAHE6M003GJOieyA6zHlPk0pn7MLvo7rSpGWLNwrPzjMZs CgPotLsWo4rJplRWAGswB26XvnSjbErpZjrdJN8cYm1UbFMCzUKbSpEmUObSFRq8RBtdW5tVhWxK oAHGkc9G/H6tilw6o0kuKWXvlF/VJHMU8hRDNqn16Ao0uG/avZjkOKVapr0eH+KdIppAE5O8txWH 3rmPIhP3oZ8P3qPUIWYQs/OMZjdAuFaVwze/Ntiilp2YmPdDNCbVexRF+H5KN1Ar3iNqYYBF9CZJ 3Swces+061jl/TQaOH4lXlsynpJfCo2h0MKxxXO+Ao1frNBavNJb5b50iQbj8JZ386NDw71JGg30 CjSrznvfr4gchTQGr5sR+tIFZ2YmmsA9A+tsagWnrfH8VCbuw/P2c3WGjFwtl02JHAWTFlYXa5pN BS+9iXiKmRjzF8527Kkcf26qsimhm8DGs2Ig1IVNCd1kyFHwwNyegSabEmhaMAZf5trhPNkUoTFC xw8UkzL7N2RT6tzAqNF5itcIISv3pUvd1OmctiOwHBzcmyTQFLfIpTFpoYqnlJgMEwTboQ0t3Ex0 nokm0AYYcAa6ElmC6qMg7kMbUfLzmqGsPoZ4p5i0MMzBUPPr7tmPNsVMjIGAxHiv/QcXvUlCNzT2 mQOB7BK5dKUb99xlHNC+dMO8SRINrpWxK93PM3Sx3FqiwSJ/K5HZfkcw0aYYTd7/xaeYvkNdVPEQ NiXRYOKlEMdLErl0hSYdzsKnzybt7cLRppQYZMdoJRYI1JKbTDSBtnuyOWMIdG+YsDucGKeb6gvZ 570RlrEtEU8xaWHZOZGnmIZNZZfvx/NTjMZsqnsLD5fo4KWhUjdY87XozneR7YQd2ZTQjWuaLrHq oRZHSTTZH7/o0C6R95NooFfAAiHfRbZ79smmBBpgYf5sM/a0tS5yFIym7PjtKca65INNiXhKopkO zQiNM028Uyym7Akp1E0k11U2RWFZ/sLwfccMHIeTTVGsWZxDyyNqMp5SpIUYJNYWVWzuBtuUyFFg c321XQJhlpUXR0ndwJpGE1PjVmrmzJS6waSUzbKGhfGN+dI1msMZQ4ntpqKPQqLB7LXj2r3EqHdK oCmQ22rrKwcVV9GbpNDg/vDzRwWWA+n7KTQVCwQrtsbt6I5sisQUN1tmYVmowYiZxEw0gabi4T54 CiSpYs43E/dh8XS21mwfjp/gImM0Rurju53j2GcW/X6KiXFia1zFfYeXisU7pXQz/EURXoadv4k2 pXRzYMtBjU2Me5VBtCmJpjljCFtG1DI2icbFDJ2WFCeRS5dooFzRj68jVudFH4XUTXY2tQKh48Fz vgJNcwXJ06ZoBF/kKKSY7BIvwycX9iwr2RSFZWesgUnwtl9bECPjKeI+3D/KneKwEQF3j96j2dus 3TxDDXs9VN6PmRjPc4OBUKXNy1X0UbBuzh+Fz12NBcldICCbEropWCDoVDpW75RC47LXjq3g+uC8 3FqjAWe/jZiFlLl0iQb+mtlUoLMVs/P63GCVlVcZJN5BIE8xkoj1qzqLaFRfuvzgyb1TkRM88SLe TDSBFghl520d8Z0SNkXch3ucIqOY4efu5iHeKSYtNGMAMQMZh7ZukrApxcSIK0xtCLWzYxJtSumm 4aTbiN2H9hvJppRucEV7tS3BIUch4imFpmAAfR4/j2aXcqJNKTRQkLLQIxT59wh+tCmpG4ju+oG8 5x/fHS/RphhNc5MnzUZGvO+XRY5CocH94T1F9i9Z82UxnlfAdBNUnES/H9EE2jt1uHdqhEEEsSsn E/dh8fSSNqI2wrkROQomLSyuw84mCDwaW/HGNiX6KLDjpQ7cXXKZpvD9lG6mH+7pvgYzisj7Kd04 sssZGa52mzLZlPpSMDDX5nb28EcJjheBxmYZ4WVYsatjZ9rIpgQaWBxkpzhyvHRRn5K6ye4Ux2l1 lffTaF5fqnOZq4m8H4sxAlnnQpawAuMQsx5EE2jGgHRvPbI4DbErJxP3YTFmtIFiapidFwvjGY0t msdX0xZHBd9P5CgUEyMM2u0GT38XW02EbYp0YyzcUGVNX0dILqjeJKUb5L02C4+cUmImUaFBPlH7 4CFhd4i8n0KDbtEp5ggvQxJ5P3luYAj1PMU1tKoMZVPq3Ez3aganbU8skU0RmuF2ZJ9oUiCsXsL3 U2IOjDVnJJ9T+6cy0QSaGEwu9P2igBgb7iKbIu5D24YELZV7gCWEZcKmFBMjNnSexpDe8P2YibHh tscdwfhKoqz5Kt1knzEJGdq95CbalNIN7GbaF0WoT3VRn2I0fW/B/v7j+cEX6urBfRhtSqFJMCFp KbJIoShqvvLcwOO7bSpUEnmnm0aT3cuQA196FvGU0k2F49cLXoaXhTO/n/xRyIrbVixz9Sz60okm 0NBAQ7lNnvjSMQ69H06M083EjT97DibEDFPEU0xaaNmEgmICE2NVNV/FxIjOvp3i0EMreJNudOOi u+Dsy7yf0s3AIr9r8rhUzPt8JRps1DsjmBR2uql3Sn4pPH4J90hdd7GyKaUbcCHPUzxCt/MQeT9G Y1Pu4LQd+P3vbUqgGaibigOTFxrmoxBi3DZr003sMcmi349oAi2AhlfSRtQ83RuSMh9OTPhSB/YX FxyL2WISczszmr1DEu7iU8UpOG3inWImxtP3K+ClEzFfVe+U1k1GMdm/mn2IWQ/WzXD7YCybFFhV usj7KTTY1WFZgdAJrnpoFZqBKbLE8+HC91NocHyvW8oidC4I30+hAcrOfYrDUFgS/X4aDVwUddMa ODTMRSbEDMf82hO2Yl9oRF860QQWN7pvKfnDT+X0KXpoifvQz9zvlyE8d+qdUkyMBWJNG2AJCbss +v2YidFsypVHQw2mqvqU0g00hu58sV8A1MXeeakbNxR2OrS+qWjXGcimFBr4az1H4uEdzpNNCTSw 1WYnF3yKTObSFRrs2e8tDnZLPgp5bkA346BJtypyFIzGBnshuqu4EePjuwGCbEqJKS7x0ppXcRE1 X6IJLH7sc89Aux9lnHJsUxRrLuz1N/8m+/tGzvkqXsiMIeuBrUpXPCVqvpKlMrkfFVtVVC5d6Saj bhZGIlc8JXIUSjfYm2S+n/9Sak+iQDP3zPX3H+2BCYUlwUMr0dTsTnEOZXWxd17qpkDr/2lTOVDS ix3ZEk3GU9ywWno9vuqdUrrJXoxPZu5qGdmU+lHQjtGtOSSk5EXNl5kY5550+f6jtVT6xAsuuTmc GNRNNQJJuLauZmtU8RC+H5MWNmzFtON3BKdtCd9P8UJmaAw2389TmtUp4imlG9ikYE4bqOZ6w0V9 Sulm4Jey6451E21KfynnbdWw5Eb5fgoNvtndOKX8jzrEnK9CA2y6JiYFGmQ1k0hobHYa/pqJeYHb aD7EOyXRTCdmBsLqIXiTWMz6mtBf3CcOolw/SuT9iCbQLNwHiStMjxbxThH3oaGBeQbLiQaic1Wf YtJC14i++0R9u2kVexIZzV7xBSo+YjtGFft8pW46ukm0rKSLHdlSN/gjrCDpiyddcZExmnWGrOCJ jl3XAjFqVw6jqa6L6HMkJOd5BkJkUwrNx+uvnWiy97a0TSk04Pt1xzT+rAiRTalTjNUyI9gLeT/R Q6t+FMzc7+curobjeKoQTeA2Tedeh2HCLjheCnEfmm5ApVbK8TPQY3IPLaOxeArSzi1vamkQUxf3 pTMa204DpRy7KHxYVhP30ErddHxgKjpfz5A12JTUDVJ+NFNx6Nvi+hSj2cYAX8oIr8Ilyr1JGg2o uFd8ti4XknmTJBqYVjY0IdWh9vlKNNgpNc7H9wXm8tKZj0KgcfeU2VTzNrUTL8GmpBjc2L1fzZD3 4z6KQjSBtogV3OuWYjITm4oOJ8bpJmEOfo/TBMrWwv1+jGYzBrt3KsQMtuCSbYpyFB1rxTu6C+1f 0qZINwd2n12j1D65MLiPQuoGK0I9RZLULupTEg3MMn6OjJR2V68A96VLNJihHeMr+eGeVjiekmgW ZtpG3HXcD2VThMZihpeFj0LRXeMeWonmGO6dWmKhKtmU+lFQWBodmRwu3bDvV4gm0O4bzBePuMil L2VTMdbcg3Yu8ZJyODfKpkSO4ughJe8TdmKfL6Mxm8KJ7LV7b1FM47yf1E1Gx+Q8xcH3EzvdpG4a 9Beft18P8wxiV45EA3HY5zhDiFDIFjuyJZoBTYzDJt38ubFXk2xKoEGL7sZFF94p7qEVaBJ2Ee2L IkyrD+ahFWgy0sQZmh72wRwcTwkxya2xGvSG75R8tCmiCaxXF8kTzYj0BDtIjDZF3IeGBoxhRzA+ Dl/MRcZoAn9xq7HDrgluZ0Zjq5qyO8WH/1E1M8eL1A0unTjFND/PsMciok1J3UDRbZdH/ZUu+tIl GmSaHi3S2bbKnJkSzVju3EQaHUMTbUqhqeiJrtio1yCALk5MRAMM5aeYFl7NxbxJEg3SWohk5uB+ PyEmOTblkSjtLHIUhWgCTQxGd5YVCAE09/sV4j60dwrdpFPFIZ46mIuM0WwWbpewm+HcHJyjYDTZ 7dixH1V9BdqY5tmmSDd+zpcj3z0SSzYldOPm7iwp5Wt3VdmU+lKwAOh02sAWnqUcsimBpgJF9Oyx 5aCKPYkaDehiHMjefxmD8P0YTXI9tLPFILEKzkyBxu0dN9Ncfj5c8aVrMfDAGJpATXUImyKawFNM wUs0x3kGIzwjmyLuQ5uB9QXJY4V3ivN+jMaWakFSqp13cfAoVDzFTIxjMyM9xXTMCl1fivsopG6w HtUs0R+SCyJHoXTTfINnDU1FS8RTjCa7AZbZIgv3zt9Em1JocMPcKSYFOhTRRyF1A+6VXelx+17i 3iSJJoHvN+sugCMawe+ndQMTkieaHsQs8U7JDw49JjPH5temchREE2jX1uFsKkyeYBL8cGKcbioO Pe+YwZdHVX2K0di6RZyBtpERf20NZVOUoxhuPYj9qHD7Va5PSd1M9G8actFdb7iyKdKNtXGAfzPI Lxa9SRINZHY/14ENvpduOJeu0YBFz4ILoK44nPsoJBpMO4+MrdjXKeaarzw3B5QA58Rtr9dFwf1+ WjfgQo5MhI4qR8FiqtuRfeqmhZXJYs63EE2goQEW7uEWQD0dWrIpijWNmghOsS249GX1qWyKchTD EcjaIIJ/fGsX8RRzZvbTowCHtp9G5HPph3qnhG4GXOkjxQ0s+/YjmxK6SRhrjuiJbveabIrQmGPy Ojcr4x8v3YgchUbzSrzMEsXIvJ9Cg9xAo3xBeeoZepBNCTTQcPM5aY/QdvbJpqRuXn/tRNNC7U70 UQgxp4V73QQ2ZWlTRBN4osH1IHb8/MtgcQnZFHEf2ni6TwMF2i4zOLIp5sy0vayvv9bGVw4NEEvE U8yZ6VPyp4WHzL5FFGRTrJvqCpJ234T+GyP1iTaldIPM9p38m91SGW1KoQGers953jd+y4j0/RQa mJAzMSGcNzoksimFBpmmB/fQQsxQnBg6N4Bm0mjjB/dRCDQWJIDvV7BecEW+4p1SYgo0QNirOTya xH3phWgCjY0Fy1wWiXhnfyqboljz/FE+fxOWhnax043R2IovyG2dNtX9VqMqdo8yGsv7He5HLf+G yxyF0k2G/uJBxDVNzE9J3SBtl3UDBb6tydzOAk11y9hWiy2V9hSzTQk0rTsXMuzKaWJXjtRNh2Z7 e6fC+F5ibmetG6gznBbeAtH5IXw/pRukCRxWygk9tNyXLn8U8rTZtRVfTe6hLUQTaGiw6Nbi8cO9 rIcT43TTkb17O7Shq0PwJjEa8/2ww8627/lLdIh3ijkzjWTBJcGrd0yqmJ+SuhnwwIz+lcTO2mhT rJvxhUMZwy1xfLoC0aYUmgaP7zKG8uAXC99Pfil4YMymwpi56EuXaDDutgaI4OwfIkeh0BzQbroO UnFiLrKbUwx1hhNcIEldIu/HYhq6EGZTJaQ6xKxHIZpAQ4PpwxyrrK2Kmi9xH9rGZrzSE03y1yFs SvRRuFRHxoL0lVwQ8RRzZjoyoCsp5c6NDdewTQndYFbAwvnA4Cl2j0rdQMl5h2UhRSb4KASa04jA hpbNpPr7pjPHi/5SEN2tg/r9Es8kSt0M6KM47+IaeJNUjoLRNBeHzxUdk42GbEqgwXbTQU1F+/Yj myIxrvfWdBPHsMTu0UI0gVvFgMaYivy5WdxDW4j70M6N/1ElzN0dIpfOnJlzRwXff9yj1D5fLGYS GY3tOvYWDjX/y6bUOyV0AyHLTq2G+0ZwZkrdDGDHOFUclvjtNh6yKYEGyXXX+eFy8ItFzVd+Kegi W4kGdEVfukBjdChgUz2apuxNYjQ2leHeKaiOPj1RsilC44p1ZuEtZGgzz09JMbDXwXQTe0wEF1kh mkBDA8fP0oee32/TIEebIu7DU0zGx7cxWYLw/ZgzczoWp9OmAus/DmlkJ8bZ1HLR3ei7+RHElCn6 /ZRusOphaaDAjqH6/ZRukKdtDBo1SiKXzmjOSxTi8NX36lOnG+ajkGhwQtLSh6GsnkRvkjw3UJ23 lyH8qCxyFPLcQAv3iSaHkFW9UwoNJqWsiTEQnSeRo5A/CnqvV9kc9IjmEHk/ogm0L+XPTVybJ3ho C3Ef1hU7M0MA3YvoTWLOzLF5/b//aC1O3i+2RgK2KZGjQFdgJpwe3jbVRG8S6+a0KWBGm8xyIHaP St1kdAVm7L3e7KZkUwINNkCsic2Iz/uGbEqgAaZhOzclUv2KHIU+NxBrji8Y8719pxiNFfnh8bVu 5xDBiJqvQtPBaRuD2r8+lE0JFa/u7pscHpgs8n5EE2i6gWl1s6kQsiqbIu5DQwMf2GwqxFNZ9NAy Z+ZAZnOzqek7pWrl2XlGc4opzX3w5t/w0oTvp3SD27Bmw12Ql+8nar6sm/P0J7jSJxII375TjObU KSQzzab8BIH0/RQazJCsTKu2k+j3U2hwmuv8UdmrGPtEixMTzw24kCeaSD6XRF+6PMWg0mGbl0OG VuT9WMypm+7umxycfeX7EU3gKaaA02bnxjejtS5qvsR9aOPp2DS9cKvVdW6UTVGOYiGbro1FrBgz iHeKOTOX+1FjRloLIwRhmxK6SZCUOnWTw/Y99U4p3TT0/RauJHjGmmRTAk3FB+Z8i+Fp+HxwSpFN CTRQZftcNU5km+/PNqV0A19qTCxzPr0tsimBxl0UBR+KC43oS2c0pxGhm+RGop+eKNmUEAPlMdNN dPazyFEQTWBdm/vs+4/TaineNFV9irgPjcPMq3iFrUZZzCQyZ+byEwSnTXlnX9sU5ShcmcNOcfPd QGWIeErppkJyYVqSIHQ7ix5apRvI+3zO43ynfo+nGM1006OnTUE0/6yHk00JNB0ck9Wwv/w6N6KP QuvGnWKiwhOzHgoN5ovNwld4p4TvJ3UDPSanikOdQXG8yB+F9alVqasji1w60QTatQWmOS23+eHE dJH3I+7DdjGVPFW84qK6PSMUbYo5M89X008stcBF1kSOgjkzl2s52Gi87zdELl3pBrhhtk2FQQT1 TkndwBs+D9yVdOlG1KcUmvVKEH+m4xq6B91M0e+n0CDh0WlTYZVBE/x+Ek09gorD4ytqvoTGLBxi TbOp4Ilm3j8l0UyMfI/YNohc8u1ezPItlS2mOmQPLdEEbvpkuEQtf+efO7F/qhD3YXM8XfuiCCrO IkfBnJkLSXltSOPla13npotcOnNmTpzzNDTNb9+zsJxtSukGEr3TkgQOTRM7sqVuUnOXaJvBMWGO lxs0r9vv9HXc+LDZlJidJzR2bqY7N2HquAkeWolmYsvB1XuLP+pgLjJ9bqB2t1qswexTTDZFaM5z g31b+esY/rlb4p0iMYbmcGhafMPFrAfRBJ5o8O497+LpqfCQ9/pwYoJuoAK5L4pAsJZFDy2TFiak 39nTXDPEU6I3iZkYD8fvN49Ih1KGyPsRmna4AZY5cRLgWWeINqV002FbxMwxDbSHe6JNKTQF7huz KVjB8vnYzxBtSn4pzKX3SPkh+ygUGrz9pu2BDvGU6KOQaCDtvAb27d3mKBhNci2Vs+I68cvCRQ+t EoM7T9aKnJlN7PMtRBNodF/QDWTlirifQfh+xH1oaNCmylfzV/re3EM2FdGcxuBYKl2f8G19ijkz 196v90ST9t8DMaWLvB/rxsZw3Ds1fOTbBBeZ1M3wrSohgpG5dIUmga9nNoWR8GO2jGxKoYGR2DMs S2FII4u8n9TNcBdFaHHaDi3ZlEBT4PE9bWp29rbIpgiN0VrAB8+xqWgfP7Ip8aOQCm/NSIUncxRE E7i/FNw3c2e9UcxgHtpC3IetuHyxnZsQh8Mqyns02b+ap00Fkg3p+zETY/hR50Xhe0yMnIltSugG N+jORV1k8p0SujmACu9EszyaTWtBNqW+FJzadJzePhS2H8tKyKYEmoYRzMLhrv2jqshRMJrDpcjs R/mcqH6nCI0VpNwp7sFNyiJHIXWDY1i2UtK/U4n50oWY7CgUl4UQ/g23OZhoU0QTGG1qYVPZre9H 3Iemm+TOTVgpuLeMRJti0sLDvQw2hhWG3ruoTzET44G9t4ZmBt9PvVNKNyU0o4UAWuX9lG5wn++e ygn1cOb3+/VLpaN+hV7IJepTCs3AVtyFG02fpzjalEKDLE7TkuA+8QLFk+LEBDTQNGunuHpeSDMN simpG9hqNGtsmrZVFmRTLOZ83+DLnGiKryTu/A3ZFIVl1jTrWnFzZI0T7xRxHxpPV3e+X5xJVFxk TFp4YDneGspDWd3SeWxTlKNYyCm0PVF/+1lbCtuU0M3EkPXaEup0I2q+WjdwpfMHz2J+SqGBasm2 KUi1bd9P2ZRAA0nQnT5EepRHpo1sSqBJeG7ccFd09osTE9HAqTU01SUzZd6P0Vh7M7wMNY6MWI8R 25QQg7Tr530zwyVaeFdOJZrAUwxWgNYR98HsqeNgU5W4D+1HHd6mAodd5ZlERlM8TWC3lQT+Lh5s U4ymJNyksHlMfNeqyvsJ3VTX3r5q3HW898EEmxK6qTtBCGjCqib1TskvhRwvKdnSE7SpOjlHIb/U OPC5S8770nO+Ek3Hl6GdYTkXCIJNSTTwhbdNTWj41O+UQOPam3eVNSzVEvGUNgYIUQ0NsOtuNJz3 q0QTaBcFplYtmxjeKeZ4qcR9aAxHvjUu8hdX7ktnNOW6bb//2EfsdlbczozG8n4w2jgrNtzd25TQ zQLCo5WQWv6yKc6lC900pLLf5CyhN0nsINBooFqWjoEEONv34xyF/FJYZ9ipDnhFdTyl0eCYecPl n3fvlEBTXFfHLroNb+HcRyHRuLwfTY+qeEqIKY7FydCM4nRTuD5ViSZwh2XOv1khfTi4PlWJ+7D5 Dbq73dQX3eQ7FdGcDwy2t3fXm3bZFHNmMpps/exwimtcJ618P6kbZNRbltv6tY9C6KZ+4SvJ3EDW qMs2pb5Uxw9+Osa+F1L0UUg0yFR0vVPuRxXuS5dogCJ4uwIxe838fvrcwJrObVPdvww866F1Ayqd PfbfqJqvEHPq5kA0aUeXiEa8U0QTaEkpbAxO57EN01zC9yPuwxMNbm2cLeZvVF86oyn2FDibChGM tClCUw63VMtehtBH0bmPQuoGVmdcYxH++E3O+0ndIC3ppKUTKpcu0fSBblLHpW47nuKar0QDJFKn mHKeIydG5NK1btD3G6cj6n+UyPsJNMXNwaTjvLeq8/2ysClGU2N1PgU0Yn5KiGl7O4XTzfKeKPfQ VqIJNFcAbr/dGBziKe5Lr8R9aGj8tZWqv7bE7DyjKdktKe4rcnXsWVayqYjGbAqz1x2Z8a53inmT hG6aq87bWERo8Fw8P6V1g2/4IN0Ibmf5pbD7MB3TWfydTSk0kEu3czOmv4s5R3GjG9d/Q2uBxTul 0JThLXwmehnIpgSa5clZjpha5RyFFpPxDe+Oxkv3JlWiCdx7OcGmSqTtakAidjgxTjcdFyNa+hAi kbu8H6MpxRHXjBS3CysuMkZjLiRWoEdkcbJJELIppZvuR41mcJNE3k/qpiR3/FbIiVbu99NoJtrU Qk6zzwfFULQpRtPc0LulD+NdLHw/eW4wKzBx+efHd3NItClGU8PjW/YUIqDJ3Ech0BQ33GPkLL5p WvUmyR+1XE7UWJl9FpL7KCrRBDZHhbbv4tA2KOpTlbgPm2PVsJehRbp+4fsRGvP9wJ0e1kXobj9L tLJNUY4i47HdNuUHEcpQNqVCVmzhPn+jPzd7DoZsSuQosEd/Tly1/rzSyabUlzrwSncLxO/yfgoN rD69UvKHi2Ayz85LNGgMRngUvK0PkfdTaHLGi6K4VSqPihDZlEIDLAfLypw+0ybmp4SYtpNgLzTt K6xMzsL3I5pAuyiQ1qLskAXFqLwfcR/GOHycV3roaeNZD0ZTsn+njq/sqx5qzpfRmJgVXIEPFGM+ HNuU0M2ozqaWT7zsHhOyKaGbCqz/JxoqjxZhUwpNx/qUtXW4PgrR7yfRIK/ADsuGe+4EH4VEg0Hi OqgiJHaPSjQw2rZPcfOvppifkmgwBb8O9Nnuar5CTNuhDurmcKnVXS2LNkU0gfal4NVcxkPM2/ei TRH3od032Lkw49Tx3hQWbYrQnO8UVPXNpkIbT63cQ8toSvZdqzSEqmY9pG4wQWc2FZrRlE0p3dTp /OLYl57EO8VofEXI6lM4waRnPQSamEtvLpv9mA+PNqV04xquTkc0zCSK2XmpmzLR27JlST5HId4p haZDkX+5DTzXO8VcZEJMc7wCphuMyx+zZWRTqgKNo9QVE7RP/4ZsimJNc69d22ASTYxkU5SjSJv1 +/uPthjTHz8kOs9OTIynvE0FY5C5dNZN9TmKRlS/XdmU0M30zK81rtwR75T6UhN9v2TLjvGD73lN simBprmKUP8KzWhJ1KckGhwzT5g9fOZvyKYEmlz8q1l9zTeJmi+jyY5rdWVct3l9KZFLVx8cwzJD U5wrsHUTbYpoAq03aXr/JvJtiRwFcR/al8ICwcJi/XVtMQ8toyk2B/E6J5t683ebIjTF917vJsZg Uzw7L3VTPVNR9e0YrTK3s9QNVudNN3F2XuT9FBrkWjWbwnSi5szUaPC5O8ZX6FoVPLQSjatrZiS8 uk6xyFHIc7P8KW7D25R4pyQaSMlvko0nmAuN8P1YTN35adRNO5xNCd6kSjSBdlHgrIdLkV7+TRI2 JerhFVmcjOqV085kU5SjqM6/sbV5oYdW8NAymtM0B3iitgIj1qe4h1boxid2jaUy1BmaqPkq3bTk rvTsLdwIaNimxJca4Z0KPSZT9FEoNOgWWUp++lSH2D+ldQOc4Gccnny5AnsFihMTe/adhc+vMIiw xDul0BSoa66C5fELDfMmSRUj/4ShwWjvkPunKtEEWo8JWnj/ysG/aaLmS9yH9qOwG8iaWINNiXiK 0JTmGTwLZoWe/g3ZFOUoiuvMXK5N9IqnhO/HujEqe4h8xxck9q93ivnShW7O0ANy6cbEGLbvLeH7 qS/Vmn+nYDXh56Nnn2xKfKnpetqm26j7aMcgmxK6ydhQfoIJmbYhchRSN4cvEGTn+200ZFOy48VV hJbPF7cuepNYTEWSzAtNdyHrEvUpoglsxfHf2FBYyPsJbudK3IcWlmHocbrXcWuj6PcjNKU4HpNR qebbRI6C0JymWfJPL4PtniWbUrqBZqQ9iBDGIsQ+X6mbiRNLbqXkpRthUxINpA9TqnvfHuimM7+f RIM9+7sVt+JdvJ+7aFOMJruk97I+mjDLKnLpjMY3v9opxlregxAg2hSjSUi/s/czhIpQYW5n+aPG 8Bbe3djnpnsjm6KwzPgkX//rNjISh8JEPEXch2aakLCz1rjYNihyFISmVCR12SzcYRmbtCnKUbTN HABo0go2JfoolG4q3jeT7pssepOkbrLTTQ0B9GBu5xs0r7+WUnP0/Q8uebIphWbic2e74Xz6kPko JBpMLiy3EeM6xaKHVqFxmf0TDcyZfz4Gu8mm1CkeztsaYdCyiHeKxfiJJUNz5F9timgCTzQYI6zz tYv0BKI+RdyHe3behazT7x5tTdSnCM1pUwdcFKPFbea1iVkPQlOqK92YTYUdBKrmq3QDKyz3OI33 RDc9QbQppZuOPCbmJn84MU28UwpNwqRUqm6c71FniDal0LjpCksfHu6dajyTKNDYylSXv5khf5NF Lp3ROFbUE00K/X77Eo02xWjOLwwqtXcqvAxVzHqoH4UehdlUzw5NZx7aSjSBNqCL1FRjE94gmqJs imLNw+X97J0Kk/xq1oPQmO+Hu7laXEMu61OExmwK2tvNwkuwKfFOKd1MrN2tr7XCuRG+H+vGd0pZ i1NwIdWsh0KDez1Ssh5ad6VXEU8pNKniXZzd4rpj91CzTSk02NPWkKX0eYrJphQaSJGZTXXXfaht itAk7NneFh5cgVKETZGYwzGHGJrqY83GfBSVaAKN8gOrZYv4trLI+xH3oZkm/LWdBgoFAjHrQWhK d0v8jNk+uVRHHTw7z2hO349Ocaj5ilw66yYjod9u/S++rJ5EjkLpBjmlbLTxpar7d0qgOdzxs0WJ zhiKeqcEmooxQ7It1a4do4t4Sp2biavhjHjavwxFvVOEJrmWg10gGB6NyPsxmsOx/ltWIC63Fnk/ 9aNa0M3h3yllU0QTuE3z9b++RxtDtzPPzldmYkyO6HxvRLi9tu7RmO8HNRdbKxPfKZH3IzTFcqIQ wVRMSl65dPFOKd3AgruLUc95W5upKNqU0s1CF7Iiwd5TN9GmFBrXQ5uMX9RdolnYlEKDNOt2isNa 4CZsSp4bdAWMYugDxTSxJ1GicZO1ZlPHr76fQtPQ25pYurvQiHeKxSRcAHPZVPJoRL8f0wRmXHJy scY1uovJpijWTLvB6/mj3J7M69yIeIrQmNOG8dSMizHVTjdGc4rJvlFv+k6p0pnbWeoGPNg93JP9 IMIhfD+lm4VsPC2y4u7UKtmUQFNcOD9xSOi7Hk42JdBMnJ9K1pzmxDSRo5BoMLW6MLV+vQzC91No 6sR4quKO9v2jmDdJoCnhS5lH4Yq1WdmU+FF5eTSl/2pTTBNYMCe2z83wzCFJzPky92HGhVOb3TTQ IDfmzGQ0p+9Xocx12lSP81Oij4I5M4fb57v5RD9QjMyls26yS3XsEbXq3vAkar5SN2DRq+8COIqp YiZRfamM7abJ9kn7HAXvyJZo8NLc5ybEU6I+pXSDFIpr4UaMy/cTuXSFBuL3ncwM9anG+3wlmuEK S+krLg0VuXQlpuH8lKEpLieqfD/Fmbnc2KcNiLsR/CT6/Zj7sOyOvqeKG71TKp5izkxb7wq+n835 fqAYmUsnNMVvbbSVgt401e5RoZuy7/6Xboobk7jJ+yndTPT9OIBuIkehvhTW7lI+wmC3TVOxTamu jonvVHM1mce1RTYl0AwcfEo26uaO3xDxFKOxNJB/NZdvDFbxlCK7nK50nB0B0qPhimxK/Cjv+7Wv FN5w9U6JsGw54hrf1vNAQzal+ijAS19GCODrmk3ZFOUopiss2cqdjw8UUwUPLaMp1vvoAmjo77zN +yndOKaibVOe+VXMJEo+0eHRxHdK9KUrQscDe5OyOXHugcmiPiUZPId/GXry75TIpUvduHD+iAye Q/TQKjRQ5rjQeJtqwvdTaLAvdDeUd7z9bIE325Rqx3Cx5nnFZ3TadqwZbYppAttu0n6hOX+kp9Ep IkfB3Id+PtzSQIFLfoh+P+bM7J6n7cBWpedFEW2K0NQU5sOtmOLEJNGbxLoprr10j326Dy7zfqwb OzdQLZun0x5aVcScr0KD5QmzqeY8UWOqIpuSaCpmBcbO5aOKRTwl0YS2weGdtilm5xWagnwUyfa0 epsSNV9GU3HQbje/hq4ONT+lxEDb2EZzOMaZTYNMNqXmGdw4TcVlgN9ZSLIp1bNfnU3VwDbYRN6P OTO7K0CeNpVjX7rgeCE0ZpqQIrPUqp86lu+U0k121FQV+Wy3TYlZD6UbbPU3m3q9dre5dMkLCRME KUciCZtlZ5sSnQtroH8zXAxx804p3RzuDe9uZM3ni4sTQ92H+NwN3H92905JssuKz106fQHfACFy 6dIYqtcNZmwfaIJNNUUT2Jr3b9bCV1P1UTTmPrSK0Mfzr21me39uOnO8MJoy3Az0tLZB/04JjhdG YzaFQ6gjVlmVTUnddMeoR0OoB8dTUjdusHtF0kJb5BNtSqJBVlyzqR7qU8xFJtBUt2NpvwyOUW9T fgSbkmgS6iZ5wnzz/ThHIdFUSF5eFu7jKX6nJBqk7bKwLIeiG/dRCDF1d+UjGmxBeNAgk02JONxF vkd1W6qPaxUl2RTFmo5Cz2wqrq8X7xSjOY0BuO/MpsIOScVHwWhKc9yH1qj38YFiSuddOVo3CyNf 80ydbg7e6SZ146g3rf3L21Tjfj+JpmNyIRtLrn+nmDdJokECAEsfBhey85yvRJNdBdp1Bt/kKN5A M7Cp7dampG7worABKnffDPb9hJjqVWy6cUlw5fs1RRPotxpZ4sX7N5xLb4qJsRaXWg1LblRvEqPZ 7xSM75U4vmcWxjYl+ij6cBa+fKZN8ftJ3Sx335w25QtLSdmU0M3MzqaWr7KqXLpE013ezxo+fX1K vVMCDU4Q7PRh6L/hvJ9AY4ufffqwN4zD6+CZxBs0+Nwtl8B7ZK/JphSRBL5T9oZ7F7JyjkKKweFl 083R/HPHsx5N0QQi8af5N9U/MFnYFHMfGtsg2NREivCnfxNtijkzh6e1SOfbG94pnklkNNbi5Ipu vuHzxqZYN5bZR9+vh3Oz6d6iTSndwP7oq1XFpZ33usVoU+pLZSjqp9zdn3WOQqLBu9fOTcnk30Sb kucG88W5bv5kECP6/QSa7vb5WuIlNIeod0pxZrqhMBPje/Yb8ybJH1VcjsItdftG8/hS38aQHv+T cIqRs3D/Ea7i87/6dRwvZz/9IKZji1NxrQJbTEqEJpOYhr315yc9Xf3ixYh9vkqM+1F+SayJsZGx iKYqMZhpszFfP5M4siAEUGKQH92CeV90G2sQminEZEy0TLcv3sRsVpX4wXsUM/yPStbE6sU0FrNd Vydm4lV8/p9m7NnfLmQQs59VJyZVXO/5ma12695w5D58/igiPMqODmPPea8ghn9U5lGj5tpNjULT +ze4edk/MOEubhhr5uOrB9Nc/KOOXINuzN165sTO3xgJSLZu9gh9SfXI528cbc6/+9O/65//8Q9/ /cs//Plv/8ef/59/zV9/+9e//fuk6X+O85/eq/2/abQD/1/7v5whVf5TquU0t9HP/+9Px2mvOf3p 4/iPABP/+e9//duf/+Xj409/+W9//i8//fd++7//b/rP3/1f//jX//5Pf/vrx//53/7lP308TsPf /fmf/ut//kv63P9P/vj8p3/8S9r/Pv///+8//+vf/8N/MZV9fP5ln8y///vHX/t7O0T45//8j3/5 x3/5r//w9PX8Fc4X+eM/WZ5Y9bR23Kh1GcOCdYv+Sucb+Sl24JDvKRa5mL7FirIX/BsdhKfYVrzY BPRX32ILoZ3wb4F27rAIxULK+iF2Qq0vPAH0EDzFuiE90y1k1L/Fvqr735/sd7HZo0WSgt/Q/vDJ DiR9O29WpPi+xK60btDeip1+ht1OAh0wy21FtNe7yK/jU2we/twWWIv48dLtwy//9iF+FZuwETMn l6B9iIUJKo/2hwPmdhQbWvfFLrTtBu0PYo/mP9kspIQ+CO3lLLDL8DoJ6CmY2MEn4bUU7Dt0+l1s 9uaAlecH2rVu0P5gDi6Hng83gQJKkGh/EovF/1MsVJSfYhNb2cODIj/qqQT0l6US7H8nXoy/inV7 HMzK8opij3yD9icrwzSAKaGTOYw7tD+JLUG3k62MT8LlVrJz+RTbsTU8u0UMD7HWv/gd1uZ3xU6M BnJxnEQPtAdb2SXwB3OoKX4ytrJ2g/YHsY5w3cTSJ1tHI7SXr80e98N/6Odfgk9WPKHXQwnp1eFY 3xM7cNTgwSBKui1sZd8Cb83BhVCnEhaQPjzErnGD9gex0xlvxkLXUyy/ZVcAcnvA1mZsf4mtOAr1 1O0rrO5vi8VM9CkWQ/eP17lN8NdeV+L1/6/ErsMfsOrAXj7Y6yQ8MxsgVrp2o/nXIS+6wWCrTBB7 3KA9Y/nlH/TJjw6kAf3L+4MSKjbt2Q12RB/MqlLfF+O3blGsVEIKaNPka1zsNM6/KMGtEDb3I5PH 2F9XTXgi75VwTO9+dH50IDf6nf9DsUIJ5zXuTsKBpEjfYj9eVbQg9l4JKaBdi4y3c3fr4za4U8Lc Q8QoNglnifsvUKxUwuz+5c3k1Syx2OMh9k4J4/zR8UFnt/k1s+YfnX+DEhor4XjVlr9zryhWKmE4 b/zAPpenEl5d1kHsD+aAMrIRBcdza6Oy0Rt/vA73SqjIA5APZGB9KuGV1gwVh3slNOTns/u30kkA xoEg9v4kuJ0C+cA1QQ+xE1ol/KPzkxJc6+2JlpWQX3HZdzIfxQolWGdKcmKRG+iBFhbwBbH3ShjO bZZKGB9vJ1XmUwk5oM10bjP7t3dJlZdY/GRbLGU/iuBkg3+jbp9i2+EP2CQfbAkf7C6p8vhP7IB5 3UKn3UPsjnnfTKo8xY4Szi18wodYoLr9LanyEgvHdIudbA7z7aTKS7fYXW3moL2aN5MqT7GlefeD Xbt9376ZVHkpoflPhksGv5VQ306qvMR2fzE29m87n4S77MdLbA5+gtPBvzWp8tLt4d3mTEmVIc7t XfbjZbzNP5GrkvthfFdvJlWeYmdwlsR9+8EJq7vsx1O3blHW1u2/J6kCYkOOsccbbPtgbyZVnkro SDqyE62E9jZN8YPYhrRmNg1Akc59CujWHCa5zeug4LRzq+3vYrs3XuDpQLFvJlUeYo3iH89tdXQz D7HH+0mV+Y3Ovw7W0cohyV0K6NYc1pcrjueEzebfYud6O6nyFNuLPwnAWfstVqQu77IfDyUMv3+w ZNcu8xBb0ttJladYaMDe7Fk501uW+U64y368dIs+WM67fSuIhcHx35Iqz5PgUkCnWCBVf+qW02t3 2Y+n2OxqOq415FssbKv4LanyEJs2syuKBaqEb7Hj4+2kyhPtEWo6Tbh2H28nVZ6fbLpHJ+Fqk2+x 0LDxW1LlgdYmX9EcXPPYtxLW+0mVl5XVcDGSx2hLAt9NqjzFHiGpkumAYXD6W1LlJdZlm9vu5/Fi BzRR/ZZUAbHBB6NczfYY30yqPF+HUbzYQU+kZXjfTao8z+0IVtY40Vq5xf0uqfJ60JN38nshJRzc gH+XVHkp4fCOaFpkZWJj1l1S5akEtx3SEq2cFq7j7aQKeIwh0iFnaSvhzaTKS7chTXGwxwhrCn9L qjyV4DbQm5/A2eaa306qPNFmzH7YtU7hHtbLfkuqvFy7EKHD4vGnEj7eTqq8Yt7q0RbKg03gt/8t qfL6ZNgBZmjZHEp9O6nyCqCQSE4G/vsafzOpAkoIebDOfkJ/O6nyuIfnHnJBtF61lxLeT6q8xMKH v8Ry9uP9TpWn2PjJ5uLUJUc6d0mVS+zpJrfhD1hMtBqPpwigbrIfT7E9+5e31hXFtvZ2UuUl1uUY s+sKusRaa/W7SZWH2IaksltsKow2v51UeYitfp9KzjiN+422c1/NXfbj8Z9YndcXtho3Eqz1dlLl qQRHYGY+2fAPuvXicsLqLvvxEGsts3gSHEX3A+063k+qPHXbcHjY0HPCqt2lKTgue6L1tciMcwPf Yst6O6nyENv9QJs1EgTjffQ5v5lUeYhNoQHmRMu9H/Wur+ZW7PgqrhZZyFlKO2Z/N6nyEJs9v4SF e+x+TGZY+kWsbSz1B2xmQnvcpYBuzeEg3RZRILir7v1gZW16scjM+EBb2Mrush8Po7aBFlTCQD79 b7H9rvfjVux5v7rsx0ASlofYfNyhvTUHo2r1F6O4E8r7SZWnlfXs3eaYbb52Zr6bVHmIXbhf6OJm oJS77Rh7N6ny0O2B3FMPrgZKXRZ+He6yH88n0q2GyoXc5secyJtJlYfYM3bAdp3zHA9+Ig/RI3qT /XgoYfiB4fOAwaaXh9gCo4G/JVUeYqtfGHKKbS1amW3NeDep8rwYa/EX4yL3IwF76G9Jlee5Te4t K3stUxALMzm/JVWeT6Sb89lioxKOyj1Ld0mV50kYhz9gZcZPlmHY5rekylO3h3M/CrIKPXXLE0V3 SZXnfbtwMeipa2z4/riumtHfTqq8zMGl17LjI3soATY2/ZZUeZ6EhvyHWyy9DtZI8GZS5amE6hq3 mui1W5PrvHdJlSfaitTJhrZFJaTGE9h3SZXXJ3P9t/JBLzxKfZdUefkJy3uM3d2LlxLeT6o8lZBD EntUdpba20mVpzk40kjzE3K8xnOZbydVXkpwB6ztEbKoBPbG75IqLyUs79pNNt6W3k6qvO5bV0PP rnT0UEIubydVXrFD9z5Y4nN7rLeTKi8rS8G1W6QESAH9llR5op2HNwcRSh/vd6o80Q5cW2Z+Q8h+ eLf5t6TKw/qmi8N2RtRdt//WpMpLbGyKSzL78WZS5Sl2hQJB4m4K4Y3fJVUusRbexckX8Za9P/7z FOt2Hu+UO+VqWnk7qfIUO8O5HRTubT/hzaTKQ2wLdd6845qINr2dVHmINRYVkGHVPSd1oxV9NXfZ j6fY+PICyc832uP98Z+nEtzKOXsiCa0tl3s3qfIQa+SY3ngbtZRgtvm3pMpLCcu/Dv++pMpD7MSh +YerR3mw+n5S5RFip02x/xJre85JbONk4F3244F2uMaBPahAJ8H2Hb+bVHmizTjzn9f2ZoPYcTdQ w3HZQ+yBhLZX5EMFWSP9ezep8hDbkYvxw3hzZyePUVyMd9mPp26xPcfyC2VSJr9xbvxnscXm5OFi NMrrRDdYZt3eZT+e5zbjDXb+z0yqSo863k6qXGKrbYiFA1YzEvV861bcYHfZjwfa9ZWTR5ud1I12 vj/+80B7IC3rRdN6ENrBr8Nd9uOphIRpimqjVlzibG8nVR4nYfm08ObtjeHeED1Ld9mPp5Xh6Ore /dG5sNXfTqo80WJO0f6cO51bNWR3k/14nltsczDjLfTJbDbm3aTK45MZbwiIrdkduAda4wl8M6ny um9dVZpvsLSZx99NqjzEdpfy2TNQB4XSx/udKs8H/cD18tvVIyU0Prd3SZXnJ+vhQcfG2UtsBibR 35IqT92mHMSKhBXTXt4lVZ66za6jtVOE/rgT3kyqvG4wl0+YbjnAQ7cpv51Ueb68yXW0LreY7iF2 vD/+87wTCsZl5UA2pm8lTF6+fJdUeb5lGd0PyzbznVDe71R5PejoNtsTSd1ra73fqfISi8nA889z kdh/Q1Ll9aDj4hf7n6GMqPW3vZtUeYrtmFQpfYeiUez74z9PJTTssNpiWQlckL1LqjzRupT7/mQf TqyhLW8nVZ5i0YvZO3coitzO0ptJlacSEvZ+nE/koLTwAVsOf0uqvPxbjHltwTgPfcz8dlLlIbb5 Gf+9yJVOwjHeTqq8zi3SMuwDR/mEld9Oqjx0vnCr+hX4c4dV5bjsLqnyFIvDSbspjie7Cxdk75Iq T7E5Tme8lQK6S6o82N0qMvLvGPjg3Hh9f/znJTYOMDodXO7H+5wqT7GHq0UWXK7xEHvcpoDuPpll 7dwny0jF/0T7fqfKEy1Sye38bSG0gvfjLvvxFDuC2CoSreXtpMpD7PkklpBU4Z6lcscAc3vA0tdy /Anlq+nRqjeTKk8ltBGKL8J43+dUeYg10h7U7enqLbrGa347qXKJLW7/5HaWZhitevi3byZVHmjH JgZ4iT2fyDD5Yq/D3bDSndhyufCINs7z6nN7l/14iM1+R1Yxq6PS/Hq/U+UhdvoKlMVlIRlor8P7 SZWnEg6XVDHyfnJE0/ucKk+0s3rXLi960Ac/OnfZj0tsvYZ7njKaLUqlpAr0jf+WVHkkBJpvme55 LzH2YveczptJFUALd4LtSKIpTvNz3k2qPNAaKxR8sp4EDY5Kr91lP67/pFvXJeh2ri+vg4023fV+ 3IndCzNxlbvR3jrB3wXZN5Mqj/+55ZuL5imVajqj3g0r3Ymd2TMS2CZezjGqjtab7McTLZKi2Tq+ Rr12/5akygNt821m08RSyr2/P/7zvG9jS0lMr5mztN5Oqjzdj+kI6Ny6kW+xwADzW1Ll+UTWw6PN nR6dyh1Wd0mV5xPpqbGKo3i7xOajvZ1UebofwzmipxLo5U31/fGfl25dh1V3O38+Pp75hDeTKk8l LNfH6CdhHrq15qI3kyqP1+EaRUKxq5H7AcNKvyVVnmKTC07t8FPdYbw//vMQe8a4aA62byK0TKe9 wu/dpMrrQccZKMt+cMNhYd7hu6TKE61rR7d8QiOxRuT1ZlLlcYMVf27rdF1BHw/jnW8nVZ4v74Hj lrY3krxxW5H0blLlhRZrOnszNbkfebydVLn+8zFwncH5547M/0/dvs+pAmLhgM1DjAnb//C7SZWH 2P5VsJFgWMGA7oSe306qPLya4V7a0yb3NejFjvp+UuWJ1rWUjPO+nXyNv59UeYidzlg/RyMOq7TH nu+op6OfcF1BZ6zgu9zH3kERxP4bYoeH2OrrZdaJLSa72w3a22K3eePo5E+ib3rcCRLtD0XDhJ/M Lkoiqt0Mh2/qdkd1FoJgZLN3kTBfjSjD/SzW+sGwU+WMfAa9DlNR6W+B6640bwM1vgxXDtLtIaaK fhSbl+9jLLbClpz8j3vK9Jui4cRt9leBlu+Ef4M5pH5cYgoWu+vhcuUPsYqK8EexxXZwgYydISWx +VYJW8jNJwNzqElRY4nej1/Ezi+kDd1p4iM+Orsz8F3drkcUeRSv28wFgvW+OVxiS/HBqemWO1qP u6sm0SrNp26xjmV13kRtD6vedqrcia2eC6hwX42JFZsn7ropLt0u18FqFf/ChS3BAPOz2FJwsdl+ MjPNnNqk+s2iAlLC9Z+37piPLfBPg5RQ7pIqd2KtzoD7bPYK8NifYNxG7+p203uYz+V6m21TDPMn iJT7z2JtcwOm11qitPCx5zxv0G4hQrfDL/Pu2WVIH2jFkN3PYq1ehqX5vWCYWkoOfiJvlXChbafj iSmgvCnRvFhbEPi2br/RJozQbYEN3Qnmn7+Ndi+xtnOL+VtD2+IBU3TQP4ut13LoF9qFix+/0d6f BFqw/dCtOZ4g4/RvfZZi6/b+JNyINecIm+JsNxUVu4235F3dlnxcusXwzrJ4B6Fdwv34WWx1K8u3 bplEYog1NI8fm+MT+dDteScsPAkdl059i113N9id2PPRcezobeD+pm/dTnbt7lKX1ZxuC0nwC32u IiYNZ3qfZ+kSe+rSMXjPonrtEvsJj/ir3qQui+8HO+Oi0+yaFzvTHXn1ndh+uPrY57QNtnyD8Um4 VcK0j7gXvQPaNbZX8O/Q7RZ7Xi1perSxb/zYNOw3up3xgD11W90upaM4orsLrbCyn8VanQEHGOek prhjz8u9q9snWuyj2evzfPDwqVdR3Yo11v29WBV9MBN7OJa0bx/s3brDFnveAe6ALV9JfaDNt0qo 8eW9/vN1OqKYybcN8Y2cJcFI8LPYbj4YKGFlQbA8Mrt2t0qwMobp1u3pNN16lrSbtoefxfYz5sXA fyXc1PyNttyiHbrucOq2VkSbDtyde4lVJGk/ix2HD/dWFeOWo4qQZKeAFsdlV2poFBw3/kznpTB6 MAflNv8ittpqX9jnWKdrr/i4An+xqe0Sy5HOJdbuGhR7vkI0wHgIK/tFrL2RsIkz1YGbOh9K2F1A xi9z/pB6HEdb6zwv/849Y3/88//Pf/aqrn/+n/8f7n8rx/ncPfa/9ZRbvfa/1T/2v/2v+Efsf/vn /yn2v338sPntn/+n3/x2/vm5+U1XcV2Sz/7tfXe7r85bnzzBfkdg4NozHwKTIxxNhxhT3su4dFVc IJxuAacJFER9+aYerhC2+JO9S/3xPXcVGvHyR0R4NeWdzoLjC7eN6JRmqFCdG+6vu4jqWyASJ5oK fDnZBFraRSPEn/yNsDiBJ8JJqdya6g1C5uBvngf70/bAUOC710SHQvr9V3ajGPZRmBzdeHa1QPWV XWe0CZzk3W/mudCYcIcw2cIJFHiVnb3AvdwjtCTcIxyY2tgC6Stjf/Q3Qj42VwNjc8PA5nWIhH0t jQqk3P/4fWxcH/gn7W/YX3mmG4TMMngKXM6Wy15JHhEyg+MkgU+E2IxoH+mgr9zGol6G+3NYV/jK qcQIYzbmRr3/yrXHY6P3SYbekB/OYcaoIiWiQLBzyKSwdwjnGQaHc5iIb9jGc2ODJx+b75/sCob2 lRdN8vX+6h1u7q+rg518aPLlx2+vr1zbDUL1UVw3ka1HTvRRertDqA62a8wxhCN0qRx70oTaSe7P ITJF2EfhOr/xLWmB8hxm9wRcAUcQ2MXM0w1Cm/NxCA9B/NyXmHa6Qdi3xp3ASp5DF0QRd2R4fgWg /feIsM0eqUYIxbDyN8IcbhtXpLgQZsHWTz/5G2FzO8pPhExC3ERz0zcZm9Dh4Wz58PfZQ4c8JvXD OYzHZjC992g3AuU5bPSMksPZeOzsDuH0Iyr7YNPmsTEW9UbdIbQLtvkLViT1M2854GPz6N1IvsS3 93TE6palRL4RhoY7Oth7QzmmGPP5A2U9ViLEn/xEOLCB0chVqP7WYaOjRygob0+EmGBOflP8N0Km /7k/hy0507M+TfmMSoEyCsjZC4xDxo8VGcG3uT+HPSI8iEHZ6ISjb/PTOXQ5VPMPmeGGm6xvO4aS 683d3bBMigCEE9n9dXGwbakqIlzb1woCjzuEYug5hV1GfVchIkJm/f/+63Swi1/qZQiJenkjjH1t 9+fwCNdX4i247U6gPIeuMmkPPRXlduAT+wTvz+FRvEB1DsXWtftz6EOzi+/WC8TFEU+EdGweBcMz LsHrq87z1aPS8XqFFcn9dXGwj7A0dVBb97E7WDRCF94+Sp2uE+Wzdhql+gmhONgWhfiOxUI5hyGa nu58bCNAd7dNPV+Q+JObIEy9921qie4cRaMduMq+Te8OYQpLV1JzDbEPgZ2nM+8QGjm7S7PYOaRS 1e1aNuUfJn9jN5EiaOmWhYgEjujO5V3oCwIXD03eIfSrhi4PlspoTXD+3SFcvii9U1Xk24zG7RV3 vs1yPdkfe6sX9XC1JoZl796Uww9CJUV4uTs1Qqx3631Vv5vFSP6566FxeHuLsHseaHtTeAf4LdUW X1/2E92wSxXM5bYG96azTAmcccyFmm2NECbGKbcI44LQ87bhKnHiqcpbhMuRrtpDX8RI1v3yt/im bIZy+Mn1dEDJx263BWchsO6h1uffNkoHQtiFj3376h2bmuGFsH8dHx9RYON5xDuE1t3mWKPWnpL0 Ao0j8fdj85xGjX1tk5z2dstpJEcw3XBYP/9MN7axLET/8HaSz+5jHBUdYgvfgCzx84K9QdhP08OD PZI76A8d5vv1aLHS262VH6+vwx7m5AW2yavG7gSmo3+l16ty/jfK+ZWKF2gEGHd9zXR9nZaBLZx2 +1ArnJUbosAfLofq6EgrUWHZ5cC9dXezArbnxzEqZV++uH5yuhu2FgKrJzjJh/jJfXBf0t18gG0n w066052L9MnHXi8VEd4KbH6hTR406nfsodXfdQgu8XQCC2WWlMN5J9DeFLdX05z4+FHss7+BcPd0 nALcVG7JjmXxgTDfD/FEgec5zDguaYsVEj0Bokv9bqTgjEa744I9LfHjIwicYnXzncDUwkKV4riX Hzoc71jK1U5ug6du5rKJzUIj320lZYHGK4OdUEX1chprJSG8GR2whU8Zf3LzDuOFUPRK3wncTjpG UgX7gL51KM7h3bhAtjAALoeS3TDvx8czIfm79/WtQ7fY1tjGuEde3dh3IwLFkwLW0zXhdmDFP3oj cJNxNyeQBy/abV+8GAtI5/8+zqK13TMYdHhL4cACzZ0LrI0HRVJdTErdjgI0v7W1NtcB+9ChQngj 0KiWkT6tqjk56zF/Q4cXwtMFxne5ZrGV0Wg93tDhhfA8NsN7sE3UU95C+N3yj0stbbCGs8Sz3M2U sECjtHcu8RQl9SbaOW/b/HvY97LEdvElOJvvBFoU4B6pEby5S4dsy7et/WWvZHv95PV18FLi8c5X vgTa5hykkDkFJnKJd+UxILxt5++bM+v1k6dbdvPQYVGEUlqgncPIrFbo1St3DdGihd/46eCjtOnb Ch4I+T68E7g5BnCWxS4HurGFf3jXtt86tnvuOGVSR5CaYrkTaIN9OJBqjdC0caiJ0eS7Vv1mw50Y mlnrPiEc92y7UWAgwN0jXVSgUe/yXXu+jZG4aHR9+Yr6XRRwJ9DGYh1zz9jdNVGHd63uEuHCbvS+ 9tRXQFjeCR4fCJPbmGvxcpxrNx3yu3zb3W/eF4a3RYw4zHy/qCoKrNnpzJrGBx2bLjyHu47+fUww ou/bRQ8IRVL3TqDpEM+h5RyIi6XPd26bRxe/sVfAQz9OZ4kyS/OW8IkFmreFz+hImxYlIExChzed +3YOUaDNdIhl7MKWbwTa/BkmJLtZDt2HU8QplGZ59O8fRrTz+tvpWL5K9fFdDv41s3QJnOZwwle2 mQhu0xKTRrfzBMc4z8nzs36m1IPH+aknUO8ErvRVMcNpKsjOmLdLLOgZ+CdfbvzRv5zAlAL9miFU qx1vBM76ladD2L7o2AxxH95OORyOoOj8b6TAxvD54M+IOrwROJubLt7JNF5KLCa5+Sd//ycFE4jn n3Mg1/rmjv1Vhw+E3TWOXcNezlv6fqTeQHjeKp/J9jYWr8PhJlAMoZjRvBNoU23ZIZzhyv58DCYS wo1H6hB2NZ7nsLjpqQvhVDrUAk8dHugS20FfR9Sh4kIQP/n8GKcOGyZh91c+RkAo14reCFynvOkQ Tl8tvZwlflMeePQ5fLUNnDrMwRfZX1mwStwIPC1lYKxn11mO19e2ZZs4O1Krbcx6OjujlD8GjP74 549//vjnj3/++OePf/74549//vjnj3/++OePf/74549//vjnj3/++OePf/74549//vjnj3/++OeP f/74549//vjnj3/+Pf/8vzSr4H0ASAgA --000000000000b0293905ec8d1d24--