Received: by 2002:a05:6358:d09b:b0:dc:cd0c:909e with SMTP id jc27csp2496230rwb; Fri, 2 Dec 2022 10:31:53 -0800 (PST) X-Google-Smtp-Source: AA0mqf5hpeU6r3BicHljXOhsLsmaNkO6yIbgWkk2fY1AnEbKzcAgHIFcRPbBftHLDiHe3Rpf/+AZ X-Received: by 2002:a63:5825:0:b0:477:f6be:b63d with SMTP id m37-20020a635825000000b00477f6beb63dmr29703424pgb.512.1670005912032; Fri, 02 Dec 2022 10:31:52 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1670005912; cv=none; d=google.com; s=arc-20160816; b=nEG/PlHKLWthICQQqS8+q2Eic2jCAgx9nWp6vUf+8+X0X16FPNtHEGXL3Fub3RDg38 AJDURsKcACi5F3Tc5EwfnR1k+kp6JCLg+kR/9g8lifP8C7Ypw0kg1ry09PwMRhSR/pgJ aV6x1OOzugdAdQpbki9tifwnKQKAzeBDorRg/yAtGgi2UuBd3ggoIllJrJ8lX0Yyu1Ru UnYzljnRLKvI1Itxj/uuEvjswhSsW4owoduK7JVrHOOAfzkSGQnAoDpE5BFjYMt4R2zY 8WrMZ3Psb0yVo3vGWP/uGIpioo27gHoibOsfPmtxicNxGPsMV0HDrw/mJLmVZRZREXAw ASXg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:mime-version:content-transfer-encoding :message-id:date:subject:cc:to:from:dkim-signature; bh=nXX2KbBbpChSz1dV3AMt0zhSv4IW0SRIsxUFsYkV0EM=; b=b+nRNftKrjImCP5r/kx/Y64J38AXnSwPB6K8kQcKel9WpUKdi+FOdYsAJlbFNtbBcs oYDjp3VaEvBma3IoShQd14GmR6pNYxMhBbW+O7l+zR/qH2hJanZ96w26pigcc0jrMm+J 3xb6hns4Y0IU8amTcn2nKzz3HbCHb0HWNOUE+1iaPefw55tYCqVyyPnGuiMt74pU5wyH CWcbYB7WqY3B+j/v7eT7nnji4dnH4Xp8zpYtFe25fdEupZ01z7zZ4k/Ucm/VZsvyhfAK UyOfqKejBEwN098x3J+PpqC6ozucM3IuZ/1mwIdNuEE6Qqu4zGYAKrfv197lDVKG4JCl 2XIw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@meta.com header.s=s2048-2021-q4 header.b="jO3twl/G"; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=meta.com Return-Path: Received: from out1.vger.email (out1.vger.email. [2620:137:e000::1:20]) by mx.google.com with ESMTP id l71-20020a63914a000000b004789508e6f3si481446pge.251.2022.12.02.10.31.39; Fri, 02 Dec 2022 10:31:51 -0800 (PST) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) client-ip=2620:137:e000::1:20; Authentication-Results: mx.google.com; dkim=pass header.i=@meta.com header.s=s2048-2021-q4 header.b="jO3twl/G"; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 2620:137:e000::1:20 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=meta.com Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233877AbiLBRlL (ORCPT + 82 others); Fri, 2 Dec 2022 12:41:11 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:59168 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233786AbiLBRlG (ORCPT ); Fri, 2 Dec 2022 12:41:06 -0500 Received: from mx0b-00082601.pphosted.com (mx0b-00082601.pphosted.com [67.231.153.30]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id B0E19EDD41 for ; Fri, 2 Dec 2022 09:41:05 -0800 (PST) Received: from pps.filterd (m0148460.ppops.net [127.0.0.1]) by mx0a-00082601.pphosted.com (8.17.1.19/8.17.1.19) with ESMTP id 2B2GRrnr022904 for ; Fri, 2 Dec 2022 09:41:05 -0800 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=meta.com; h=from : to : cc : subject : date : message-id : content-type : content-transfer-encoding : mime-version; s=s2048-2021-q4; bh=nXX2KbBbpChSz1dV3AMt0zhSv4IW0SRIsxUFsYkV0EM=; b=jO3twl/GqqjOx9zI7E0IRjFCMuGIFw0alv4X/HHbP65c6yu9ClxOrRA6vuBgIB4HvXYZ w845WuuEBabmqF+GsO+rCi0YjPkqruo8SKmVpuqZRNhDuPESYSGjOho8iZvplsX5DG57 jEEHGJaFF5faWA6Vvsrekl/yALtir2NNwu8PThW01doWjjmsB6DBd7ZRxEjdMp1FByBk z3hfk0ZwhREU+63NUissKh7cGWTB5BF3dwuCgNVvv5QiT56tqj0sIVZIRC0q3bvseT6Y XekCB/VD1NH1wbMf5LyrPOsfP325/wOEsLiYFoL7kfwJ9vDl12EdLJ7i8qYzxA34w9PN WQ== Received: from mail.thefacebook.com ([163.114.132.120]) by mx0a-00082601.pphosted.com (PPS) with ESMTPS id 3m7mwc0p66-18 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128 verify=NOT) for ; Fri, 02 Dec 2022 09:41:00 -0800 Received: from twshared4568.42.prn1.facebook.com (2620:10d:c085:108::4) by mail.thefacebook.com (2620:10d:c085:21d::5) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256) id 15.1.2375.31; Fri, 2 Dec 2022 09:40:56 -0800 Received: by devvm11876.prn0.facebook.com (Postfix, from userid 343873) id E4BF4402F8DD; Fri, 2 Dec 2022 09:40:41 -0800 (PST) From: Sreevani Sreejith To: , , , , , CC: , , Subject: [PATCH bpf-next] bpf, docs: BPF Iterator Document Date: Fri, 2 Dec 2022 09:40:39 -0800 Message-ID: <20221202174039.3360904-1-ssreevani@meta.com> X-Mailer: git-send-email 2.30.2 Content-Type: text/plain; charset="UTF-8" X-FB-Internal: Safe X-Proofpoint-ORIG-GUID: oMhYm8O3FsYfHtzI4fonuDg3EZHNGB-B X-Proofpoint-GUID: oMhYm8O3FsYfHtzI4fonuDg3EZHNGB-B Content-Transfer-Encoding: quoted-printable X-Proofpoint-UnRewURL: 0 URL was un-rewritten MIME-Version: 1.0 X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.219,Aquarius:18.0.923,Hydra:6.0.545,FMLib:17.11.122.1 definitions=2022-12-02_10,2022-12-01_01,2022-06-22_01 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Sreevani Sreejith Document that describes how BPF iterators work, how to use iterators, and how to pass parameters in BPF iterators. Acked-by: David Vernet Signed-off-by: Sreevani Sreejith --- Documentation/bpf/bpf_iterators.rst | 487 + .../bpf/images/bpf_iterator_flow.svg | 9589 +++++++++++++++++ Documentation/bpf/index.rst | 1 + 3 files changed, 10077 insertions(+) create mode 100644 Documentation/bpf/bpf_iterators.rst create mode 100644 Documentation/bpf/images/bpf_iterator_flow.svg diff --git a/Documentation/bpf/bpf_iterators.rst b/Documentation/bpf/bpf_it= erators.rst new file mode 100644 index 000000000000..db63a9c55338 --- /dev/null +++ b/Documentation/bpf/bpf_iterators.rst @@ -0,0 +1,487 @@ +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D +BPF Iterators +=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D + + +---------- +Motivation +---------- + +There are a few existing ways to dump kernel data into user space. The most +popular one is the ``/proc`` system. For example, ``cat /proc/net/tcp6`` d= umps +all tcp6 sockets in the system, and ``cat /proc/net/netlink`` dumps all ne= tlink +sockets in the system. However, their output format tends to be fixed, and= if +users want more information about these sockets, they have to patch the ke= rnel, +which often takes time to publish upstream and release. The same is true f= or popular +tools like `ss `_ where a= ny +additional information needs a kernel patch. + +To solve this problem, the `drgn +`_ tool is often use= d to +dig out the kernel data with no kernel change. However, the main drawback = for +drgn is performance, as it cannot do pointer tracing inside the kernel. In +addition, drgn cannot validate a pointer value and may read invalid data i= f the +pointer becomes invalid inside the kernel. + +The BPF iterator solves the above problem by providing flexibility on what= data +(e.g., tasks, bpf_maps, etc.) to collect by calling BPF programs for each = kernel +data object. + +---------------------- +How BPF Iterators Work +---------------------- + +A BPF iterator is a type of BPF program that allows users to iterate over +specific types of kernel objects. Unlike traditional BPF tracing programs = that +allow users to define callbacks that are invoked at particular points of +execution in the kernel, BPF iterators allow users to define callbacks that +should be executed for every entry in a variety of kernel data structures. + +For example, users can define a BPF iterator that iterates over every task= on +the system and dumps the total amount of CPU runtime currently used by eac= h of +them. Another BPF task iterator may instead dump the cgroup information fo= r each +task. Such flexibility is the core value of BPF iterators. + +A BPF program is always loaded into the kernel at the behest of a user spa= ce +process. A user space process loads a BPF program by opening and initializ= ing +the program skeleton as required and then invoking a syscall to have the B= PF +program verified and loaded by the kernel. + +In traditional tracing programs, a program is activated by having user spa= ce +obtain a ``bpf_link`` to the program with ``bpf_program__attach()``. Once +activated, the program callback will be invoked whenever the tracepoint is +triggered in the main kernel. For BPF iterator programs, a ``bpf_link`` to= the +program is obtained using ``bpf_link_create()``, and the program callback = is +invoked by issuing system calls from user space. + +.. kernel-figure:: images/bpf_iterator_flow.svg + +Next, let us see how you can use the iterators to iterate on kernel object= s and +read data. + +------------------------ +How to Use BPF iterators +------------------------ + +BPF selftests are a great resource to illustrate how to use the iterators.= In +this section, we=E2=80=99ll walk through a BPF selftest which shows how to= load and use +a BPF iterator program. To begin, we=E2=80=99ll look at `bpf_iter.c +`_, +which illustrates how to load and trigger BPF iterators on the user space = side. +Later, we=E2=80=99ll look at a BPF program that runs in kernel space. + +Loading a BPF iterator in the kernel from user space typically involves the +following steps: + +* The BPF program is loaded into the kernel through ``libbpf``. Once the k= ernel + has verified and loaded the program, it returns a file descriptor (fd) t= o user + space. +* Obtain a ``link_fd`` to the BPF program by calling the ``bpf_link_create= ()`` + specified with the BPF program file descriptor received from the kernel. +* Next, obtain a BPF iterator file descriptor (``bpf_iter_fd``) by calling= the + ``bpf_iter_create()`` specified with the ``bpf_link`` received from Step= 2. +* Trigger the iteration by calling ``read(bpf_iter_fd)`` until no data is + available. +* Close the iterator fd using ``close(bpf_iter_fd)``. +* If needed to reread the data, get a new ``bpf_iter_fd`` and do the read = again. + +The following are a few examples of selftest BPF iterator programs: + +* `bpf_iter_tcp4.c `_ +* `bpf_iter_task_vma.c `_ +* `bpf_iter_task_file.c `_ + +Let us look at ``bpf_iter_task_file.c``, which runs in kernel space: + +Here is the definition of ``bpf_iter__task_file`` in `vmlinux.h +`_. +Any struct name in ``vmlinux.h`` in the format ``bpf_iter__`` +represents a BPF iterator. The suffix ```` represents the type = of +iterator. + +:: + + struct bpf_iter__task_file { + union { + struct bpf_iter_meta *meta; + }; + union { + struct task_struct *task; + }; + u32 fd; + union { + struct file *file; + }; + }; + +In the above code, the field 'meta' contains the metadata, which is the sa= me for +all BPF iterator programs. The rest of the fields are specific to different +iterators. For example, for task_file iterators, the kernel layer provides= the +'task', 'fd' and 'file' field values. The 'task' and 'file' are `reference +counted +`_, +so they won't go away when the BPF program runs. + +Here is a snippet from the ``bpf_iter_task_file.c`` file: + +:: + + SEC("iter/task_file") + int dump_task_file(struct bpf_iter__task_file *ctx) + { + struct seq_file *seq =3D ctx->meta->seq; + struct task_struct *task =3D ctx->task; + struct file *file =3D ctx->file; + __u32 fd =3D ctx->fd; + + if (task =3D=3D NULL || file =3D=3D NULL) + return 0; + + if (ctx->meta->seq_num =3D=3D 0) { + count =3D 0; + BPF_SEQ_PRINTF(seq, " tgid gid fd file\n"); + } + + if (tgid =3D=3D task->tgid && task->tgid !=3D task->pid) + count++; + + if (last_tgid !=3D task->tgid) { + last_tgid =3D task->tgid; + unique_tgid_count++; + } + + BPF_SEQ_PRINTF(seq, "%8d %8d %8d %lx\n", task->tgid, task->pid, fd, + (long)file->f_op); + return 0; + } + +In the above example, the section name ``SEC(iter/task_file)``, indicates = that +the program is a BPF iterator program to iterate all files from all tasks.= The +context of the program is ``bpf_iter__task_file`` struct. + +The user space program invokes the BPF iterator program running in the ker= nel +by issuing a ``read()`` syscall. Once invoked, the BPF +program can export data to user space using a variety of BPF helper functi= ons. +You can use either ``bpf_seq_printf()`` (and BPF_SEQ_PRINTF helper macro) = or +``bpf_seq_write()`` function based on whether you need formatted output or= just +binary data, respectively. For binary-encoded data, the user space applica= tions +can process the data from ``bpf_seq_write()`` as needed. For the formatted= data, +you can use ``cat `` to print the results similar to ``cat +/proc/net/netlink`` after pinning the BPF iterator to the bpffs mount. Lat= er, +use ``rm -f `` to remove the pinned iterator. + +For example, you can use the following command to create a BPF iterator fr= om the +``bpf_iter_ipv6_route.o`` object file and pin it to the ``/sys/fs/bpf/my_r= oute`` +path: + +:: + + $ bpftool iter pin ./bpf_iter_ipv6_route.o /sys/fs/bpf/my_route + +And then print out the results using the following command: + +:: + + $ cat /sys/fs/bpf/my_route + + +------------------------------------------------------- +Implement Kernel Support for BPF Iterator Program Types +------------------------------------------------------- + +To implement a BPF iterator in the kernel, the developer must make a one-t= ime +change to the following key data structure defined in the `bpf.h +`_ +file. + +:: + + struct bpf_iter_reg { + const char *target; + bpf_iter_attach_target_t attach_target; + bpf_iter_detach_target_t detach_target; + bpf_iter_show_fdinfo_t show_fdinfo; + bpf_iter_fill_link_info_t fill_link_info; + bpf_iter_get_func_proto_t get_func_proto; + u32 ctx_arg_info_size; + u32 feature; + struct bpf_ctx_arg_aux ctx_arg_info[BPF_ITER_CTX_ARG_MAX]; + const struct bpf_iter_seq_info *seq_info; + }; + +After filling the data structure fields, call ``bpf_iter_reg_target()`` to +register the iterator to the main BPF iterator subsystem. + +The following is the breakdown for each field in struct ``bpf_iter_reg``. + +.. list-table:: + :widths: 25 50 + :header-rows: 1 + + * - Fields + - Description + * - target + - Specifies the name of the BPF iterator. For example: ``bpf_map``, + ``bpf_map_elem``. The name should be different from other ``bpf_ite= r`` target names in the kernel. + * - attach_target and detach_target + - Allows for target specific ``link_create`` action since some targets + may need special processing. Called during the user space link_crea= te stage. + * - show_fdinfo and fill_link_info + - Called to fill target specific information when user tries to get l= ink + info associated with the iterator. + * - get_func_proto + - Permits a BPF iterator to access BPF helpers specific to the iterat= or. + * - ctx_arg_info_size and ctx_arg_info + - Specifies the verifier states for BPF program arguments associated = with + the bpf iterator. + * - feature + - Specifies certain action requests in the kernel BPF iterator + infrastructure. Currently, only BPF_ITER_RESCHED is supported. This= means + that the kernel function cond_resched() is called to avoid other ke= rnel + subsystem (e.g., rcu) misbehaving. + * - seq_info + - Specifies certain action requests in the kernel BPF iterator + infrastructure. Currently, only BPF_ITER_RESCHED is supported. This= means + that the kernel function cond_resched() is called to avoid other ke= rnel + subsystem (e.g., rcu) misbehaving. + + +`Click here +`_ +to see an implementation of the ``task_vma`` BPF iterator in the kernel. + +--------------------------------- +Parameterizing BPF Task Iterators +--------------------------------- + +By default, BPF iterators walk through all the objects of the specified ty= pes +(processes, cgroups, maps, etc.) across the entire system to read relevant +kernel data. But often, there are cases where we only care about a much sm= aller +subset of iterable kernel objects, such as only iterating tasks within a +specific process. Therefore, BPF iterator programs support filtering out o= bjects +from iteration by allowing user space to configure the iterator program wh= en it +is attached. + +-------------------------- +BPF Task Iterator Program +-------------------------- + +The following code is a BPF iterator program to print files and task infor= mation +through the ``seq_file`` of the iterator. It is a standard BPF iterator pr= ogram +that visits every file of an iterator. We will use this BPF program in our +example later. + +:: + + #include + #include + + char _license[] SEC("license") =3D "GPL"; + + SEC("iter/task_file") + int dump_task_file(struct bpf_iter__task_file *ctx) + { + struct seq_file *seq =3D ctx->meta->seq; + struct task_struct *task =3D ctx->task; + struct file *file =3D ctx->file; + __u32 fd =3D ctx->fd; + if (task =3D=3D NULL || file =3D=3D NULL) + return 0; + if (ctx->meta->seq_num =3D=3D 0) { + BPF_SEQ_PRINTF(seq, " tgid pid fd file\= n"); + } + BPF_SEQ_PRINTF(seq, "%8d %8d %8d %lx\n", task->tgid, task->pid, fd, + (long)file->f_op); + return 0; + } + +---------------------------------------- +Creating a File Iterator with Parameters +---------------------------------------- + +Now, let us look at how to create an iterator that includes only files of a +process. + +First, fill the ``bpf_iter_attach_opts`` struct as shown below: + +:: + + LIBBPF_OPTS(bpf_iter_attach_opts, opts); + union bpf_iter_link_info linfo; + memset(&linfo, 0, sizeof(linfo)); + linfo.task.pid =3D getpid(); + opts.link_info =3D &linfo; + opts.link_info_len =3D sizeof(linfo); + +``linfo.task.pid``, if it is non-zero, directs the kernel to create an ite= rator +that only includes opened files for the process with the specified ``pid``= . In +this example, we will only be iterating files for our process. If +``linfo.task.pid`` is zero, the iterator will visit every opened file of e= very +process. Similarly, ``linfo.task.tid`` directs the kernel to create an ite= rator +that visits opened files of a specific thread, not a process. In this exam= ple, +``linfo.task.tid`` is different from ``linfo.task.pid`` only if the thread= has a +separate file descriptor table. In most circumstances, all process threads= share +a single file descriptor table. + +Now, in the userspace program, pass the pointer of struct to the +``bpf_program__attach_iter()``. + +:: + + link =3D bpf_program__attach_iter(prog, &opts); iter_fd =3D + bpf_iter_create(bpf_link__fd(link)); + +If both *tid* and *pid* are zero, an iterator created from this struct +``bpf_iter_attach_opts`` will include every opened file of every task in t= he +system (in the namespace, actually.) It is the same as passing a NULL as t= he +second argument to ``bpf_program__attach_iter()``. + +The whole program looks like the following code: + +:: + + #include + #include + #include + #include + #include "bpf_iter_task_ex.skel.h" + + static int do_read_opts(struct bpf_program *prog, struct bpf_iter_attach= _opts *opts) + { + struct bpf_link *link; + char buf[16] =3D {}; + int iter_fd =3D -1, len; + int ret =3D 0; + + link =3D bpf_program__attach_iter(prog, opts); + if (!link) { + fprintf(stderr, "bpf_program__attach_iter() fails\n"); + return -1; + } + iter_fd =3D bpf_iter_create(bpf_link__fd(link)); + if (iter_fd < 0) { + fprintf(stderr, "bpf_iter_create() fails\n"); + ret =3D -1; + goto free_link; + } + /* not check contents, but ensure read() ends without error */ + while ((len =3D read(iter_fd, buf, sizeof(buf) - 1)) > 0) { + buf[len] =3D 0; + printf("%s", buf); + } + printf("\n"); + free_link: + if (iter_fd >=3D 0) + close(iter_fd); + bpf_link__destroy(link); + return 0; + } + + static void test_task_file(void) + { + LIBBPF_OPTS(bpf_iter_attach_opts, opts); + struct bpf_iter_task_ex *skel; + union bpf_iter_link_info linfo; + skel =3D bpf_iter_task_ex__open_and_load(); + if (skel =3D=3D NULL) + return; + memset(&linfo, 0, sizeof(linfo)); + linfo.task.pid =3D getpid(); + opts.link_info =3D &linfo; + opts.link_info_len =3D sizeof(linfo); + printf("PID %d\n", getpid()); + do_read_opts(skel->progs.dump_task_file, &opts); + bpf_iter_task_ex__destroy(skel); + } + + int main(int argc, const char * const * argv) + { + test_task_file(); + return 0; + } + +The following lines are the output of the program. +:: + + PID 1859 + + tgid pid fd file + 1859 1859 0 ffffffff82270aa0 + 1859 1859 1 ffffffff82270aa0 + 1859 1859 2 ffffffff82270aa0 + 1859 1859 3 ffffffff82272980 + 1859 1859 4 ffffffff8225e120 + 1859 1859 5 ffffffff82255120 + 1859 1859 6 ffffffff82254f00 + 1859 1859 7 ffffffff82254d80 + 1859 1859 8 ffffffff8225abe0 + +------------------ +Without Parameters +------------------ + +Let us look at how a BPF iterator without parameters skips files of other +processes in the system. In this case, the BPF program has to check the pi= d or +the tid of tasks, or it will receive every opened file in the system (in t= he +current *pid* namespace, actually). So, we usually add a global variable i= n the +BPF program to pass a *pid* to the BPF program. + +The BPF program would look like the following block. + + :: + + ...... + int target_pid =3D 0; + + SEC("iter/task_file") + int dump_task_file(struct bpf_iter__task_file *ctx) + { + ...... + if (task->tgid !=3D target_pid) /* Check task->pid instead to ch= eck thread IDs */ + return 0; + BPF_SEQ_PRINTF(seq, "%8d %8d %8d %lx\n", task->tgid, task->pid, = fd, + (long)file->f_op); + return 0; + } + +The user space program would look like the following block: + + :: + + ...... + static void test_task_file(void) + { + ...... + skel =3D bpf_iter_task_ex__open_and_load(); + if (skel =3D=3D NULL) + return; + skel->bss->target_pid =3D getpid(); /* process ID. For thread i= d, use gettid() */ + memset(&linfo, 0, sizeof(linfo)); + linfo.task.pid =3D getpid(); + opts.link_info =3D &linfo; + opts.link_info_len =3D sizeof(linfo); + ...... + } + +``target_pid`` is a global variable in the BPF program. The user space pro= gram +should initialize the variable with a process ID to skip opened files of o= ther +processes in the BPF program. When you parametrize a BPF iterator, the ite= rator +calls the BPF program fewer times which can save significant resources. + +--------------------------- +Parametrizing VMA Iterators +--------------------------- + +By default, a BPF VMA iterator includes every VMA in every process. Howev= er, +you can still specify a process or a thread to include only its VMAs. Unli= ke +files, a thread can not have a separate address space (since Linux 2.6.0-t= est6). +Here, using *tid* makes no difference from using *pid*. + +---------------------------- +Parametrizing Task Iterators +---------------------------- + +A BPF task iterator with *pid* includes all tasks (threads) of a process. = The +BPF program receives these tasks one after another. You can specify a BPF = task +iterator with *tid* parameter to include only the tasks that match the giv= en +*tid*. diff --git a/Documentation/bpf/images/bpf_iterator_flow.svg b/Documentation= /bpf/images/bpf_iterator_flow.svg new file mode 100644 index 000000000000..898df1bc02a6 --- /dev/null +++ b/Documentation/bpf/images/bpf_iterator_flow.svg @@ -0,0 +1,9589 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Kernel + User Sp<= tspan x=3D"88.51" y=3D"0" class=3D"st2 st3">ace + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Close + + Rea<= tspan x=3D"17.76" y=3D"0" class=3D"st8 st2 st9">d + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + prog_fd + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + link_fd + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + iter_fd<= /text> + + B Sys<= /tspan>calls ( )<= /text> + + BPF<= tspan x=3D"20.15" y=3D"0" class=3D"st8 st2 st9"> Iter Create + + Loa<= tspan x=3D"17.26" y=3D"0" class=3D"st8 st2 st9">d + + BPF<= tspan x=3D"20.15" y=3D"0" class=3D"st8 st2 st9"> Link Create + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Out<= tspan x=3D"17.52" y=3D"0" class=3D"st8 st2 st9">put Buffer + + User Prog<= tspan x=3D"89.79" y=3D"0" class=3D"st8 st2 st27">ram + + BPF Bytecode<= /text> + + User Space B= uffer + + BPF Byte<= tspan x=3D"72.81" y=3D"0" class=3D"st8 st2 st30">code + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Capture Kernel Daa + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Iterat= or + + + + + + + + + + Trigger + + Verifi= er/JIT<= /text> + + Repeat <= /tspan>to + Re + -= + read Data + + + + + KLUv/QBYRKoDHjyEiQ0jkETE+e/xOlybj4Z7zOvra3oG+ROnpVT5i426EYkAACIAAIBSDa4Nf= g2z +Uib1po2B0w+jTT7rGfmemVoh9fAsc7aI5b2nXDKFvWMoPc6Ex1U+rosCBk7ScHJqGqkZOEm9B3= lB +L6RFILWpr5csoMrPrx0mw03dCxxtDkxnIzI0w0iLivesfTTkiUhbHfW4SOX1OcZjxnADTXQWdK= XU +9MWsKiJDDUERHX0CmU1SgbTkfFaPiIzep8eFPsWkStaRq+xMCdhNT/25gWYto80SdnaCMnucEc= xm +7RsQhXbGkC7GV1qg9rjCSC9AiEpHxg800UUmR0fZUCMAcS+tW0rXRLFT5DsuCufGcVFSNXtLZZ= k5 +z5XfunDT5Zksah2R6D1OgHJyURIhlvqTxQq75ZBY+3zGnG2AkKq/bFq0M1PrGn7i0CtPL9SIhT= Ri +edBOtcYqM4p37igguPcgKh2Zogwtr2XoSL3P02IyslQmjAuqEUAvGyaDgFaekd0gFRPHRWE9WL= PK +cXxCOhoUSgvDJCmPC0lvkZaSJjjJuC78E4kszk/Dtem8lGF8pRHj7JBmwZHWWtFOjzsHQKnXJF= Le +qFqsQqjlJGMFg/44N1E8lrKSEOFCW8tYSqlHkxECGh+gyMJzwM3HejYBNwfcfL9KE7DhIk3Q40= LB +b2PYT0kHBlMRoVvwEPSOQTdXC/ij3jHof2W3fm+cH4AV0a+bqIZjS+PX2A4s3tRwbBmla0kk4O= TX +kqj9r5q6lkQ1HFvWkmgtieaviesbSruwP3/Wkigm+6wlURyDMa84087xp+cf4M/vG8PEVzwAs+= 9L +dmm0+IoHZDA7fxlLvy/rpgJUUMMu5H1jGOzO72/jWivL4lvTb03L8lvTsyy34izLnfFlbM0VZ7= kx +y/L8A7hzKhjwErQfdmM/nQEgzrIcz8RZlsVZlmGZS/8WvsUvT7PiKx7gr3hgfmE8lmkw9n2J81= vD +350DmOOZ7L4xsZ1hYjvDZHMsm//L9gGwV4ZhMPp1a7GdYbMAosy+8w8Qi+0MG1DTvHbrVzwwq1= sX +gA+7b+y3XpxhMdj9MlaeRVpNNrMvzmP/rec4NstvK9Zw7HWjxRqOvT/Af2cWdl+s7MO1GCbScg= 3H +MFauxbD+irQ8/5ad0SIt158WaVmeR1k9/wBwDOuy+8JYt4bZGPbpWyvHoiwg/rU7A4Cm/yzLN1= qU +BbwvFv4w+BajYZj9RHpu57gm1mBuLJ5l0SsYjLIzKipGQFlD9Pdr2BVrMNqAGmz+szoWa7D2/5= cC +i9NP32aZrdXuS3zFAy8xFovb/9+XSKvJ5L1dOoZdQQwLSgxKs+6LCtwaRhkdg45EFMFueEICAf= +V +3bcSm//n/QLcD/etewEgnsksLEJrmt3A323ZeRVgUIFvYRZ2NwLRRxX0XsedLWh/O8ewH9oo+2= dU +jucKWwv4o09c31ABBm1bVmaMdSzTNJqtia7cNt4Y5r7sf1+CX7NvTLsyQX2LabAYpgkE/b3VXF= ow +f5mVBaVsFniHX3jyJeiCOX5jGCsoMSgtaN1ZJhgAg//MyjTMzrWgxKBzLXrfmwWD0j5yJEmGDE= Y/ +jLXUsb9Z1LSbymAXgO+WHAu2FvXahUkjSTI+HYvVsb+Zydx/geMA3Dm++Ftced9fIXsAruh9f2= Ws +Y3/TPaOO/Y2jHFC7MFb2jCihBqPhxzr2N9xB/nldNBzkQsCvOeu+rMCtYZZBi+eaFnzYfetbLN= /k ++CP4MvYmg9kNDGZf9iUIoJh5DbuzPP8AseAHmD/9Zzl2ZX8WCPivXIthAtl9YTEB7xh09KWDLB= v0 +7Fpif7NwNEqx90Yj9jcCkuy+wXDAMeyLBPwWxvxagPq+v9Loo0PgaPDOuejHhUMGuzPahdnSHM= ev +5Qdwa/b9pOLXbC0aULuv+3Jpt1SL6zqmLBxyPKpnMjfUat15XZQNgS+742vo+tM0+t8XW8+xLE= Dd +NcxNPwEkdF9fNLMBPhzD7afB4jfAg57ZAAEetIfU4pq+wVo0bPjgtyaArdn0v3KNpR8B6F/fXu= 5c +1yz85/Z1ZzAIXX/Rf1+sO7MBOluzLVv/mjygLm8vGwD+bQwrfhvDb01AS/h+G3c2nNOGQELop3= sB +Z5QphkTaAkRny3LRvvrLASMVbTmyCs8bC0VnXy+Fg/2ft7Dx63Ds1i4df0Lx6P0hviA/Qcvjat= iN +P96XDYHvjUYXfLSZ5QxgX5l2009Qw5gt4O2vYf/9onZm41c9ozTmE7xxTNmCAew8o/vX2I6g/v= Sf +P4L5CwS9Y9BPIIPduRb9Noa5MGkLEKvazW0/J/XVN7m+efjY8rhQgBAE4M6/ptmQYEZ/jqDEoJ= /g +ZX9oCzjZB8ys+xDslsexNZuWLay2Fn7ha9rdUD4c7MNxAZxeHwEXcO7X9X/ZTwurHQ2t6vfGxn= 6a +AkAmU2O0lzqHYNRmTyeBUadDefnm0rhoQDbw8lIDACAjCkAABcdEGFgq0IhdatlABiaTefracD= c9 +hUGyTIAAoxFMUWmpDFS7Ax3XQTY8w8Eguy9H7igd3Td4w+HHsZcNLnJBoy/I0jd8OfKx4fC8LB= mL +cSFygaOPi0VvLBjcl2UnRZD8YfiYf30AGAB8lEVGI8l0aewyk0xWZVnZYRBB7KdbwEE2155CJw= Hn +WgFfpQQcAe8CAARdMCDggoyAcwNOnGNPAk56R++c9A1y0XkpcsGi+0XZPW8wygV3+F4yeh/HRd= nL +BkPkgpIzypI3PNl9o1w0RM55BPy/cs0VbS4U/Brb2QKEBEMO2DRiIdIKbgEcw+jHPQQwADGs2R= z9 +3wG1qJ7RUqEgRQLEl9mZSNDCt1iuxZVfuzeRYP4t7MZmNfs51R9m308Nu+xmZmH2/QHcDd3C/6= UI +ZvTL3cxgNQuAaI5rt1UFAdwa9mV6/jDXfV+2Us9oPaOzmv3AHvjzxvHojeORYEbfZopg/nXNwn= 5N +DxD9F+bWM/up0a4cvz8ArNbmOPbTT4AQ/Jl9LQjZZcVPgJDBLoydR4JPgKhhf+DlEbQ/AHeOa9= gv +fVwcgzHyLZ5X2JXd3g8ndzgZ7NawO3/guNMid+uNX7UBotbm/ivL7OYLL/gy+AcQv3vRvYCt35= 9u +R9kFAuJZltndKLvgZWFuy86bLDsnYGW/5tmlowtedpb9Gna3K+8admvjWWZrtRu9YzG3fVm3nl= l5 +32q7Ozo3/5r9s2zT9H8H1C7sxmB3Mxpd8LI3269jeI+NLuiMnvrygNG/zSNBC6sCIwHfO8W1BA= 8Z +7LYxDFbHX7vRo1aGVEccHM8sbNM+HMviXd/Yt3abWRl8m20OxtZxu3+AP782HM8wtra3S9P/re= OW +RCJ5PB4MZnMYjKqiKrq5FmbpWzyr5y9/mn3BH9bG7vzl/b7aN7bd2Obi+aaycww14LduALd9X2= 3t +7xnNtvDf3I+36kHR/WGsTG/apWX3fX8d+28d1/77ujfZ5mB3jt9YHcMvC3Nl8VtjX5iAv2EA4h= aO +3Zr+N1u8P/th973BaLbWzvH+sAu7tR9r5/hW2/AfcIPdGn17ZW5Gsy/t2Sq6Y7+tY1jctJmt/Z= ad +613PZO48QI5hu/3znzdHv68WZmvzl+2ZzM4ydmblXf/3vb02HLs17NNbBrvv/Gt61/CH7f9n2W= /3 +/GUytr1t7na77TiO43hzsOu67v9/cx/GslvAf2O1G2x2Yexm2U3anGf/9nXrzv71Dcaqm31ft/= 2w +ypbB7oxu2qX//N0W3Q7fBT8AO8s2oxT8Vwa79K/jm22XI5fi5Fv9RbL4jeeP53F0Df9aLa60sO= p5 +nIgjcs6ptDz865p9LX7RHWRnNMrSl9yXvXOH6BD4RuvOa6tRKgTc9wfsytzZ82Xsx2sA8N0S2f= 5W +C6sA/JqF51+/aKvR4F3gaDC8YOSlgDE6uoA3vELw+G4pHsFf9rR4x6AetxAs/KOWtQK0Ym6rhn= 8N +x5UW7Mo+pdXo9PwHsJvareOob29M/1D9ZTM76uxrqWe0Rb6/jTklBvW4Lnj8l4WJvmxmN62Fx6= C1 +C5Pm/95CnC8WonpGPxx3BA8AvhvgMxqkgNFwCBijQrBwvO6IFHnDC0ixbCx+zb5y7Y9a44IUcE= ZJ +02a2JsczYgXHriv7odTHBQ/KGvI8jgsetAx26/qLvoytYVoNDOpxgseXsTSpNWJQjxu9Fzzm/6= rd +Ou3r3igt3zFoF9RsbY4t/3UtLRKDtr/9vzOz7032Q4pawB+Bnse1FJFCpt0U5ta0W3Nr2SN40D= Uc +W2gw9qUIAIjf96MEbA1/GcsRwOyAiuBBz/Eb1/Cv3WBx6nlco/QLvigdI8lHkWQsBKTvjgYnue= eM +Uhx5KViUpIOPjN5gLEqGuGgIGuNi0UvO4KNj5CL9Q+7F8zgGYyFY8FKwaAgYpOAhIKbIYLeFbz= HF +87jRMTK64PEDcGmaDQCzFc/jOKiA4R+9C7zfjd274PFrNoVjFyELQIsD5BgmeFnYtbRY2edoWv= XM +zio0/WHx/Hk/PH9Ny3sF7y3GolH2z+oJfT7B47+1O/I8DvEJEKzs1+Bf0+5M+wSPObaQIsMLHn= Ds +0vMvtRwY1PM4Li68ABH65rhm55q+vS9GIHjMcc3+ueJ5nICLo+K/4hZViD6dF5RRPXToWGjMoW= 2e +nwwXV7XaxUKajLNnwPaVO3cKjGVAW0CV2gcMm4ZCVf3LYUYyOIZyIcGIXIcU9lq+qRVs5scBS9= Dj +SrCNAAIyK3AP1HRMXYcBn7OtQJqJFv39h40IpnkpwSQqPBgs1GCHLGgXslEOiBlMgkosG9QikN= Y0 +KZSRp8cJ/BFG41BBtE1rjY5vRITxFbmg6JXNC+y0T2X45TEQf0gTbH+Be6ORBe1gjsfdukQkPQ= 28 +PIZygfFgL+Hr7HIw8GgzQ2YVfTzKC3EUPifPkOhkAqvSGSs7F8+ldRWH2s9zHXK0bnMJ7rcZEq= vo +eavzPHsc6OO4+OE0ung9hlo8dmKxuGfwWnEEKRTgX0lh4jcJq8Tfmpd4bEaTeMnFjHj5Xw+XxW= ob +3upgNlxRgla+cWMLT0EaC38oBlS+B1SVe1xMc0cgKgSJgKXNhIDogETsZhfWoUMT/dAZQJXXze= xn +BGYi9T7dkHkoGw20jjhmnWbJQnsEKT1Oj5scUi1vmZgMI0XyAjvoodL4ZxA6jO/ZPBZdHE+WmL= fZ +aoK3GckjsFEKsRLjJcnBi98jNrfW0+l0mlv8e5wUnMl0eg3YPmgN2F4Z9Bg3nUKES66IiortEJ= NR +q4xazZL3OJBGf74rpASNRtDozxN/QKwrhpYfECOixX5OdBKd1tIUia4Lr9Q+tY+G4ZEm49hpZE= 33 +SJNRIz9Ik/EAekw0soEAang9moyZ2sJWFsZMLfNpekZ8FEZNn2REBmZg5jEDMwxmoE6/Cf04/2= qC +lwtt1hd/kV1kLpZ3+c7yLt+eKP4CWlSWT1Mfp4ZPGpKkY+WwQEnUOn6AHoc+Ei7OKw=3D=3D + + + 423eksRtDj+Sgy/4kqbjCF0cAgTQyiisLVfaWXgExieisXCRtQxWiMWbmnyIGUlv0ZMfB0Imv= jAH +kgBhHWXLgFahVohQo8BJ8P44IRaoVOVhXhz+gyoR6NCkkw7Mg/e41qI6fVZwkjJAVywZicBJKs= p8 +QmrKbEql09KR5EK+A4VHO9omxhOUs4EO9Nfng0aHjpFHzNkb0Eb49BJx+dpmctDNoVfe4yD0Rq= V2 +Cv3aqAr9YnAeN7fmlk21+lEx6LFRMegxm8p0QphOptCAtalW1Tq3SqXSyaBSqf0QO8S4xx1iHL= VW +DiQSiSRCE93T6M87jf6cRv+4tHpgQoRosf/QYr9G1pAeaTJ2GlmD0BwaHhc+CB7oMdFo5H3L9E= wt +M9rKwi3TM7Vv8ShkapnC9yhkardMn9QS1WIT45gBsnWi+Its3B538Wwniu+nj7v76TOY1Gb9eY= 9b +W3AcLSwH3DxVqT1VqV0OUSpLBVOV2lVWp0CZKkvtJEyV2iEbkkhTCZ+mPC5NPWnqu1lqH6pCE5= 0y +Iz0nlWUjMODajYXwuForUEGUf6RYnd1hI3aRWeP7h5IrXBf0CrVg+VqoQGB4ies2oxCpWsFmXh= yh +PyPQIkrH0cJamW4QdWIW3gcsA9rjBFALAsODZD4CKkTXbTYMIuXDDxZep2ePMxTKzShWQmnYZU= QY +2J0Ds7AbDczCDlVm1DKj6FgjquhUVinsPK4FghWdjPbzPCLdPBw0j8izJMI00Bel0M5Vtna2Ss= uv +Xvu4wn6bDL7ffDoRqlBoGhu/xUpli5UYp1+oE+qECulXR4mnuXUiv8fie3yP2I0lOfjKKfwefH= sc +OOgyqmQYoCq1R6V2EUTEpbi0miRDZYMmeoW2oIleodGflBjBohUWrbBoFa0myMko0el2ui680m= I/ +b7Gft9jPNR3oMbmdDFtZGG+ZPsnUvK0sjBlNn2RqGW6g6ZObXBZGOtMnCHKc0Ss/o1cecfjqlf= 8m +CPWbgKAFRnzRK3+JOVyCNnddmNR9FJpgH11ktFnPDZe8rrBo9eCCz0xqE1xjTujX9qMdNL+2IM= hj +YS2304BVu9UELaMcolRWqlK7HKJM0OMUKJWlziFKrqhUOETxNCV+ClRicEjMJ5roho8J1gwfM+= T5 +QkPLPVrrNncSz+ATPO2to+iksA/m1sWAsYRdhMQgqDpCRkbPD76yqMWrtGle6LLiMhRqISdMZ2= JG +dkgvBAydqy5ycaDmdeVkt7JQBIaHQbEoWCoELVR4fXJcONB8fxz010VoKS2WmGRLo+gqNBPsPm= 0r +7G6I1NeN2lbYiVilsDOF0rDrEE2iaykcim5DM8FONDALu0Yh9HW1YzOKB5X6OHmn2E7F57iox3= US +Cxc9LY+w29LD51RZG84eGfqsG0q+g+6DgTLKppeEfq0o0DBAUbxYiXGxEuNiZXaieI9DKVAnij= /0 +kuTgT4qS5OAZ32Nuza25tZrc96hTkoMXv4fHhd9DMeidM2A5Z8AOWJEzYDkDlhx0m2q1qWwq08= m2 +GbAdXAdsP8Sc0Ie2Q0xGraVT6VQ6GTAqtVdshxhP2A4xbntwJAcPSsB4tj1uQxQQNNFHGv15XF= rj +UlwieRyCRBOd84aWV0an0QmBcF1k0aQIwcSHcF14pbfYz2uftfZZTdGp9rkuvELHlAPBdeEHjx= s7 +0GNyigytRtbQMWXhkSYd6KGRERLSZNTImk6ajJQQq5ETnUeajPXnMQEzpK0sjLdMn8Sl1QQztr= Iw +cpxRaTL2R2H0uD6pJBSVTG3wKIxjpraWpseJmAGETbWafmYZoCR6nX4TjzuA9cpjBjCEGjOA6G= B6 +pbKHlmMG1tJUIMYXbdYmaHtwvnWieI/juNjaaCCF0eMuMoRG/SbgZUA7UfxlfJngxV9kNOtE8T= az +NgW+R8zjTrZDjK9t6Q98Tmqxn3vcSijQJAdPCREypQDFr+1amh73fS+Ju7uSdjkU2L62Kx1TTp= KD +nx002wLkSYmVGAc/Sjja/MsEQRVPNTWU28pb2C/kSA7+cGthSpoJWuiYYvMvudOvTao/97iztV= OV +2j3OoFlHOeRMNPpzlWXwuNpnNYifzwmKjaZPQLWkUsMHwd11iDIgXKsCZYKqx+MoIVYOUbHIPS= 5x +a6EGPcYTMmo1ISDE4+SGxyVuLQ7oMUn/bHefw+FzC9UQwycHT0j/bHucl/7ZplTQRKeE2JgTeq= pp +giDOSq/UnqbW0qSl6Yn1DK4L/5DW0rQcPiaY0jHF9JK42/PIDKeE2FNkiA0fEwSFRIvNYdB1kV= Nh +J4X9HLWfbM4SQ8spIfa9WTxjE0ooKh/ERrWAeNwjfBBAqEULMsIFj7s41lRHPYE6jo9aeFw7+x= vD +aBRbuK9ZBgXRIoVaqG4MG4HACNUgEVDsrtvscQXR4htE3hWymZ0WF8dIgw96JhgMbalYXSzH9X= gE +BogysnCP261lcEIt4i7iJWbkYSSYHA8MAio+koMfzJ8HyEGrAzTRES+JuwmcSGwziqkuMs+3k2= Tz +A+zg7NQrkwi1zGEkmKNosbksIk0Q1GxKpQITKRUxogqkI5RFIEU1JiNL5VDv0+sTkGrynGBfNd= Ab +S1q7x2Uic2h3LqphTEsMrMswioPaVkPqByZTjD9glWxZNpcRlY58vUrq0PJKQlHxuFC4oDwGSJ= rT +nY1JwgJyzIbGgf4GkRLcAJkWikygEw8/WKj6xwGmTLd50kXm2eMS7EYAcXHQWyxtB5oUuRgujk= lI +qGf63KOO2Jkkeg67iAryjYVLNzno2eNAdZ67jKHllwtKMvAYHZD2scxz10U87iCK7cZHgMHqBU= uD +wZ6k2raaPc5VDzwveaHIFCSxXqwWqwOk4qxm1bs2RoszUVkh+psaPQ71rY6PkyJW84mGtG8NGV= eH +oXPIaNXscQtDy73XqOJJNosDEwqo5hENEagjkBHMIg2aAVRHtIt5dj2t02NYZgDSdNFrMc8Wlo= HS +CS+Od5X9Y0lNQuxzqwNF3kxgJEpaIZRwQcBZQh6AHsenKWJbrbNAWSzucRPVCCGxeKnKHN4H7S= J/ +6gHO4LXS2E6rLwHrBj6m43GH7pJyLSiHJQkFuLtqEAT4hwD5UBOBQW/R4x6DHuPdfnkmQ0lhU6= 2F +T8HkcZNO95UOpcIbWm6qKZZkYGwS5oFV4piUpCOVuMddZrvzR27NS43UuhHVN42i1Hh8YhoNQo= QZ +8UXq45wjLqYWmsW68RMY3DRGjogrUhH3uDkWRY3AQWOLzWQZSI0ReV4PZ3lcCAPzcPXFUjkOB4= 3+ +rlDCO36stuEeF5dWmKvdyA1DyxcTyqJho11Ab2j5yDjADHl2GdAJ0WLzscRsuCmgvtBE//x4br= hE +wEJTqT0kotlIjys5QOtJfGEOp2ItucKVsypq4Q0ERsaNQxzX4z3k0GVl4SsJYoYLFJDGwjuIUK= PA +aC0DGtHhpYWjUAIlAoHxKVAMxYDK6dPQcguDoOrEjWVAi6LF5h5nIakqB6meiMo/KJfzMsEZsZ= jn +T7TY/JOmCcoITeVRGF2dhRzOPKfAJMFZTAqJmccdDh/z8UJAuBtargoVXl9BdN1Ei80zkgsEJC= EW +80xvLp958GSHww0eNwN9z8tosb9U6yBURKzEOEZ0rkgc2tMLEfSYzDyU2ieGKdsK9x63wX6YW2= QF +NNCv1QRvjs0o2iScQjdjhCQdOqY0aKfN3XQxzx5Hb8DNR9/B6BcJhdAEo0U6Y1eR4R3j7GxM14= D1 +22J1eTW1ifGQRYTxo9dGAjJclBArRxCy+XHAzT1uv0oTcK0HbB8oXErzXUkTlFGFyFXGqWf1sP= B6 +n6KSRSA9OTW5JlzY8PDAGBf01k08LhePikS1ECqQSdjWHmEpEL4Fq27v3SLh8p4vgM76g3nUc3= oc +NNPZOPumEYk+41B8v3kdlNGUkjav3ph0aYxnFBiER7Ef4+H6xUFXhuvzrhhztiiOGih6sIXd4w= bz +R3gForFmuETy+ZyB8BPwcjhTrw4ULr1Vm5mdhp9W0XaCF9F2XiguOnrcjBqgo0OMObuQcsizU7= pZ +Rs+D3hOVkHwyvOyfzxuhn4AaSufylbJL+NfARiRgGUOYEnmCKYyDupL6c7XR6igGE3P2RdGAdV= OW +hT1ieX2umLwzOqqhvvYy9LVN2EvJF3ZVbWC2op0jR+lxjsIPOq51qXeadH1+AJvXfrL15zVXez= ex +Pg1HMTSwk9tPQEvtEeMVmQLWU7W1NOcNooPSIlPYNSOTy1cKKYTPwK/FSQqhos982gZaKTRg/c= BD +qAynWPraF9tPwLPy+vw8dC6vqsl+7HOCEB+neykLOG4kH+M9sVVHLbZCp/c5otK4x2lGLjoKoI= aS +MlZYsrVDHqTJeBl4hD3jbsqIuSk6l+/IUhx0M4I9fDMQ4qAeRyf2rFMOHTrSlZizP7EK4ddJxD= B6 +KOelS1Lyq/tJahP2NGFbe0Yh0dhOGEP7HMz4DkoooMBRM5Og8xyYtDzhr51dYjOzboqZXF406h= Ie +Jcle3aMqrC/GVZCLjhhRKhM9nB7IM2SZXF49U/IsRNoQ+i7WzzUDLM5GeDrV30zg9yOBLuFRS2= Xt +JKVT/SmTYgKZQsaDmY8yKmbtDH1hAuikpRQIX5O8wG6ozKFdIlHoyHGV5NmoTxS/FloxvjK8S7= /w +LsZPqlQDDUEKGR+LOjFu6zCwHkPYxVnBEDqb4BDgoB6nWEHv6fjqlV83a4ZHSHWGZ1IOeXab8Z= 4i +z3mcHsXCRT3OpuhUX/NUXp2SWju704lo+K1wwhYoldo15WgYLy4DZcSICDJ5bs6M6A0VV+9yA+= Gi +G5IHHOOZOUNXmNB+ninMwj4hsV4dEnrEeDkhoQ416Y0GhU0+FTUw471BQ7RB2WMZLzADZaTIE1= hf +aRjY6UKq5Wmjj0c2UjGw7jhfnz88F1g/K6u7MYrOMFJCrNhXDTTULVw0PWPO/lTSzzkwMzmobX= Cb +oZqVOUO7xYRRmmgOFrIvxstNDzujUYB1SYV096ZMGMYJHVPA2vG1lu8/YYl0blnH5Se0LOwVCu= Vz +wunhc2JqLM5WsC7D2LkU8vRmzUV1+Qipa3j5IE1GkSmhekrtEeOmjaVtgE7DQ7z0jiaRThvvoO= M6 +cPn8Yok5O0OTwq6uNmX0uA6zOV0hQklI7SebW76kvjz72rfBT0CP86jnpWvKLuEVIIKZGICl/h= vQ +pBOx6VSfjuzi/BJWaA/EWdY/o8RFT1YB1g0bxkEFeNkZVW+RyT5fhn4SmdFxC7yWMSFzGcaB81= v7 +G2KFttqJsF6JdC6/ukiPgh6mTR9jJ3ggw0swNtvrOBrGRa0S9jREA3vEe8QAwjCazBodHY/X57= aB +ScvXJ1ZoExopWNekWuQ5kQuK7nFzwrXpha4GUb3mtLobwxDgmVnneIkPHx+jBooBqbzR42QS09= kZ +mfXq9cXVeyTUNXzmrk1PjBoOrJvRcdO+3A1SE4bxIeCi41mDeSOERExIqYY8WY9YAw=3D=3D + + + 7U4ScIxJ9dVtKVlo3zSZWcdw2gZ6+Ryi/0Tb2lVcQ6tIE1R4rFf3G8ald0gTnGheJN+blb/ol= VdY +Vo7LM1mA57q5x4mDzdoRnRmmoOgWePBSXlpZGFcWc3MeRzLplsjCriFNUAFuwp5qWWr/Eo/H97= Vc +RJ0o/luYmxsQHENuC6lZzZNnLU2xQm7ucYpLKCETF9IEQxr9vwtpgmKL/ZxVTZORk2iiK2b0yi= dE +ie8xbEPLPbItzNBMsIuQUogPD4EiMS5hCwhPq1YdRUlmZ3ea+dXphcAMvbQQNO4h08f5QdlKBh= 6C +oOPokSYjzGTSoJdTSQUZK9IESXDN8AbdMoylx3FZOANFqQExEQmLx5VqcjFQb24LSQ7et52tN/= /O +vnbOqmHiqd7cQXC8FI+FMavEEKzPqNE8G8flNSlEy9IaO9bY0szN5OBfLFqKtk+0zRUh2qId2d= fm +sceUpme9dk+9+Om1Sa/NQ4LrwhWeF7tgUYTWi/AYP+on1OYe12LS0T+cltVRghwZhMcpBCrwgO= 3l +BnRaS3PgAMsehgi7U4WAS7FBbV4TDS0nRAgmCI5IExxpIs4eU5+dIH02D0k00bfns/nsGbDdsf= H0 +wvGSuPur1J4ghJbP5q3zs/mtI03GHlo3vw3QKw+qThSfCA0tFzErK6ysHsdKSNbNX8914azuQW= WQ +wrgxE5IAxSsqkkqB7SuTSYN6HCgxN0c0zM3Lmr3wlcnEMeTmpY0GU+sHKbbYxLjiQpqg4nvEOC= 2W +XEgTBG2HGL+QJpj4A1+L/XyLH+d1rSyM4oC2uSmThd3B8aol/pBmC9IriQ56g8PGXk6csGtHVN= FN +HGmh6wxAYJc5bMV2pIUupZlgVzpsRbfoRBCdofYHSYvw3PRaxkrk8DlpG1ZomyCbWfeUXsv4Dp= Q2 +3ZQafN9hCE7DxfEweOAsPM5kdmiHLKmYOC6KJPMArR5n6YBgjJEqkHZcjAvKqJEXVB0fmjMFWw= TS +uovTlYuOtOeT4agSDBxr3/RowfQ4qMfBj5izUaJQA4VLG+En5+vzL1S/CSzjcR5n6KPYiQn/Cf= W4 +06BiUjcQcJKOnI0A5LYYfD4YoamvOyqMj7fY2aJYQ54Z1slBLeWoeluK9XmP09heD7+0E497IT= yO +U2YUHeR1Ed1poC9f53EkmU3WC5g964WGadNvYEo7CQ83tG+UWda9RSyEvrTXDAVlBCwjSUV6j/= O4 +xsZ1mz3O4zyOLpAX1BIhxc7Q7rgooye9K4J7vOFxg/Vk6Ta0luEUWRZ2mkR2tleJGEaaikKe8i= eA +zs8Ibfl6VNEx7VJe4ONxMMtq9bgQYlo9DrR6nMd1pwmPBSQc2nucx31EGNh5TpywE1OFrwspHI= rO +FmN8hvPTcJHDK500ZAy7bBBm+IZdO7sQrjwuUZZIZ2m2If1ox93pobbogZrIMEqZarybnSgQjC= Gh +GJSIVOdWvgO3sZv/STfAvqgl8dJaFrSvA7bbSqSpPhbz3LUsrAHSCFUlQpPYv0zwsbmZFjVo+6= vG +rFL/Q2/cBqVlluEQzZDgJLV0QDD05HKIdlAUk+q5SKlQKCmER4S+h5vSy3s2JPXnM6vy6jPBxt= kE +A8Hl4Q74fT2SgKOKQ688JNF+svlpDJBi3ONqoNR/iq9GeJzHifIF4T1uoHDpHoca21boiLkQnU= fh +UHSQAQhcDczC7mA4LWj8E3ZO9zjDNwqh9WrwPWZMqD5lC6mXbNbO7qChUEJR8Tge+5jgF7IVjv= Q4 +j/M4mQLmcafa4zwu46aL9EbzOI9bE5ODL80LkRKashvkQsisKm2oUFpMklBaOKMlpI80Noikzc= re +0kitiEQ8LiRJ1R8ubQilLTFn73omnbXDSOOPBSrD6czhc0YwPewD3raxm3tcKFyYqR72kCTjce= vY +is0Em6H23F1Nj9tpoUQyLx4XomUgZ1/VLYspIoqpN3mcR8sSHtfVWt42piOUJlnXVJUWNBDT42= KU +6XHuas5kep88RV5Q1an0ria8EYB4XAhzqOV58SpFlGZWlbkjL6hmUu9zI6KYVFG/kau/OdSyQ+= i4 +KJQI44KeDMYFLTmf1aMhm4R1wkXFjgA4yq4NZ3ucOBJLZ4mhfV4vIC4Kis0ZClYIIjQThrVoYz= cP +hQuPI8t3NbvXoYAVh9p7HH3zxs/juI0KHUqna9vg0+NoqotVWVbYQ6+P6SiK9wVZlug8bjaVRu= hM +wAVVmmAeIuhY+bguHi1LfB6TeZ55GC61G9UtC0aiKZ2/RPNDgwZ2jxNDh8d1hpvZof08g76PRn= G/ ++jhDm8d5IsJOdOKE3ayAgZ2GZoLd5rAV3Ua2hV2EcEh4XMfiw44iwsCuFOggOkbtv/bmjd05yz= oH +ue20cPXVYwsrtGdZAeuzJXXRVFa4dBIJ8ihq1EhAhstWIk1Q9rhuMCETcFBuRhH0mLQVjzNZPc= YJ +/KRB6U1cQ2cUae6WZXM10SKZHgf2zbqVk3VbeUoNvSxEj6tDi83dlNLf1EK7NUyKbtR2dvdzUV= Ws +yghtpZXxobKpj7NQYJigw4UguC4cshhxtiT10PCvVLVgLlZ9pZXxQZANsRQUQtJuRkePQ82X+L= Sd +DqVzNljcyhmfKlURIZjgR3BduGhATE6Yy2e5eWEKQjaeXkw8sNR7HEFAMqeHVUeHaFAsLSzSEb= qJ +yDwo4RK2LC9YEqvMrpCYtmYqyJlowTxHYDav7nHhQqRS+wx7s20TLZPIOfhuIjTDSGHSbwAyQl= 0k +mVpW58dDgVOac48DCa4LhzmkCZotKcY9lGRzMKVIfWLuNpATNqBtjpJsXlnF3mzQCqgeJx5YVt= 2E +LrbGrLuJUNpcfgh9aIipCj7QKJWKTGA4RgdlRLQsmytqMG88bDTRC+mf7e4NE5oJdh7HRRjYqU= Cw +ojNfF9GxFA5FF1ISiK5i8WHXEWEg4hMAu0zbCjvL4gW78xMAu85hKzofSkMPaQGOHXV0+TZkwi= jG +l0inx3FGO6yTFeNpiHR3WugM4+IgwjqaUqR+gjE7ux9SqTdZRepPCGKNpGD9ca4Z3pAoYL1y+r= hb +wxOG0eO+wWbtpkhwd+k1uXykTKAjBWN29uVQYNmu4YeWZXPfgjmPj7T2HVtNMAFaTdB3735KDK= wn +VpXaNR1Ew78VygQjilBnbD6UpES95Bk6qhvS3Ye2hI6d9uPuxKyZRFweBH1MMLyQiJIyThZhZ4= MP +cnOfKmgnkMdtg5+AiXXAepzHnUYhQfUYL9rOQqL0OG+Lj2HEEG4ztB6YtHzEG3E2RsZ69Y3AgM= YN +Jauydo+LN68MB20F6KQjmVm/vVYdvXQ2zibAOHnCo2vTP6aN8KbXQ5PoVAMm2B1ISqLzOG+eEd= 2M +E0F03okTKlJDy2mxxHZQafzg8dLp1iLOFpEFxvmK0NRjwrOBvh7W51cUVSs8jmyMJANDx0lKok= Og +o0QHcyKITiVQ+LqTw+MI3gNttKk3SAyzbot0aLxWXYZxVQ+fU9JYcbbqM/keEX7QkYw/jxuFhA= Tn +L0QpQaBasQQmYcNDxR5GxmlkwJ0EpuUN9MNUPdhGVB+SaghPyxNYp0Pf2uObzNkGVkLjHofytu= Vv +hQbCizeLoeUe1750UiiTJ11TiDYBRiFPj4tHlcZnmMA44ZUiw0ExVcvT56eOtEKw46BkWwiaKj= Cj +UvsXIi4e93XL4YN4bxaz9DpluKXQeqMP/QTMjLWWj2wYEDY1jOvp4+7OpTQZKTQD1k+2h73/gc= 8r +pNXdGkbEMIKSNcPTAUXqe+gnYEdNITwm0jGMqhrYILgFkeBuQ8uy2w0pP2Ic8nh9HppQJphhaR= le +8VTCLjtoZiQle/Vvi5hPhvtD642IQY9xVJNYY5ejRDshTJXaQ48afLwIJdn8U3TGcB2wnfQ4j0= sL +qdTX6uZ0z9iA9U8BBZ2y/vrcdmJ9njbYOFtE8lIwxqPqi6AoCCTlkTZQscZ72LgomPfk4vwvSj= AE +N2EHyZ0x0GKWz5gGNK4S4xoKL0aczRJ1yqhSOpenwRsHjWwqr55IBTy6nj6xox5NRgn6uIGdYq= Qi +upQQ+rpX9WGHwSwMHXeEixVnk9bV56wo2tR/VrCHq7SAN9ZCstD2uMwkBevwd3nPi4v0qGcKcF= AF +R4lipwp6EZTN7eTiGRMk4FGbymUcJh5H8YgerQXAjDeIvPeET1qGyyKVN9JimbMVsoXGQy0YOB= be +3/IpTqRt+USp+P5yIjs7xLKWkX6A3jMTeqVTkUG46EDtkhwEwE4iwsBuTjTIfaDRn6NCX8vJSk= Jh +qtSa4VP7xLaA8JSWpCnM1j6hGQjvcSM8kOEmxjQtpLszCfHS1ZYU447XgO1nh0F4CekL+2PDuP= SU +fbm7Y1INY0aFFEaKR6Z4xISR8H2kjBmwndRw2MrC6FOV2k2mGZvhjwfpbgbLuzym/bh7k4aWl0= Ap +WE+ACKaCRMwOYaeAhPBCmmAI9Vgz3OMkm772R8xBGTOF1hsHkpTs1RUqycEnQCGMxoWOaSQF6x= kY +/DzOUHnEOGHA8r1ntSljjKm8usdpWLOz61Z+dQeJ9eoTRcQw1qWKjoWExuPCiMfVFZTLhzIJjc= uh +V4avNAiNbyznDL0dGiesVxQirHu+BI1/BoRBxvi67TIhupHFh93uRBBdjaYXH8nBWwqcGK+/A9= ZX +drP2GAR51HP4Djqnh8+p6bzOrkHYDLVN0Fn/ECVlbBggE4PBcGgVlMpAEtmE0pKZZ4aKWNu4KA= XU +wPkcUYOg42fp0HgcqqxdhV+Lc01ZoU3wLIx/YHqMh1AdjHpcarb5yC93ox5n6FouY5M0AmREdl= yU +TYgNj9qpdvMe900oiJIyfiIJdDTLFKwfMhwXTWQQLlpgWXC81QqpV8+Ys0ETT9E/IgHL6Mk8lt= Ek +e1wNqjB8tHF735zE97SxCqL9yRZwtNWrz6mWHcPYEVh1lNM9eZqtDsUqvs5zWslRKrVvGmJB1v= 7A +52M9mox0pk/oRyiuA7bDIQoG4w9pMnynTKVeHZggvHnqMa5SIuhodiaXX0+Cu1cuIH7cAzIZRp= N9 +xHjpgaW+sojNNinWcflzrpxkn/e0qsLwuA+iUjtKAsH6YCSAwtPksk2MNwppjJN0Jca9TIpxBv= 2I +8UVJcvDdG1qu6g8NLyty2D3Om1bz+wOf09JMq7aCeFxENYzirU82rfQ0ycFnNqG7DROCCWpINN= FB +nVKIAilLMJPLpzUGrEsmbMcsfBDDw70oycLjCuVoTzwacolSbyk71dMdx6yDIBjbOR86dNywzM= 4G +IRQeJWwyoh/rmexxohOY8SUZ854FM/2cqPt4nBUSa+0ZF4GDRr4YZ28gZwPdCMRop8d5nMcRPj= Tb +N4o2w7uVu/aDZ4u2qHql07Kx0c5ZBb8/LS+wfyHYw9XwU7+eKGZcUBpooml4HOYmUiqR13VLz4= 4x +Req+OL1QHFTEYjjoqCSWzkJs1dHQ5Oxsjeq++sUxe5wiE9JBaSftc5BrJKDHMVweRw=3D=3D + + + M021Vu+ZRO3zuUX5nBb58nlcYYV2wTS/usXjvafaGX3OhJfJE8U9TiTCwI42Y0Jp2EVkW9idC= J7o +6obF8HE6+OGQZyJFubzttXJQDOlbuyqJOVveXYwTPF46CSdJ76Jbrxz0pkIR/vvtDLXRXjO0A1= t1 +tBN7aFwWdcLeeRgHNXjcCEaTKzlQR5JChYageFzjKyIRAZE1q6T1QekiVxnfn0hT9d0MGka40N= E4 +4cRaxre06qhtn539UbTCfrPFHvd5HAeqKkVHQjSJrvC4gV2DcEh0AgqHoiORLIaOh4aWg1+9Z1= RI +i9xXJyxSLT9gpDL8ZL0yXLO9i1ZOrM/bYhZne8q25RNiaTsTnhLa2M1Za+ceWOrF1dByxGOVRQ= lU +pfZ3DUu+g44MH6fXrLWzewIFjpVJwuUHSDAPP6znDJ3hGO2cfUZTAQM7CM0Eu4dhK260Dy3Mzc= ca +69UtMswbEw1y80ls+Daa6KovXnwkBx/7V/g9m5ud/A4iCYaG9nAhTXCLHz+IKss8fWGHnGAIf3= 6x +2eYIdFxeUVkz/HJovZETOS+9EhlV7xpYS1N1ThDe7PFsX/hoGP3hhHX1JDP84UBMwIpsknqM2n= F5 +knZhvTI8Y4q4PIaOKWBkE8M3i8mBeLHZNhwmoQmSLC3DPe7QsixaDs6GOQ8Gwi9oIs6GOaGmEV= u4 +qwny2OpaTbBEOy2+euU9GhM6ngglZXxIvrCbl8NAQ0OaLO00p195c7tSjCtM14Ur4LIwii7npS= 8G +K872JxjCUyTxbJOoSGZ4Ah2wvXJDXUpOKUSBXEYBil9jl6dPkoMpto6tGC83IIRHv9hsi0yqy1= NC +LOSAMaEmAu0jbSkDhUvisl0NuvYeWOoxAqkXTaQJipJLSGtvHtd5J183U1WKzqW5iE6DjhKd2b= bC +jgvAWiFL+3km0E4DL8g5QfjLJrgu3NDRLCOBHWQ8bfA6G2TYSCct7YT98fjCXnCktJOTCTVQTQ= pV +QEWcTasUBNeFh60TxYskgoTOumbSIvzkW3G2x/mOgGVEDyKsX2bS45SkCqkPnfOmwwKvGLRhHx= Ns +rEgTZCxen3ucq49IE+SfVkB1CzcRKnMIrNZf+NSkx1EkGxDCUyp0TAk3s9OCgcr+4jCcYI6UJv= tL +opSOJJoVCIZOJGQJepyhfb1kocQhJyx6DgPSZHxvllRdc9CvZqFxETsjz1oPMzz1rJ0Nqhhm3T= b6 +osfw0eVPA2DGJ7iG3HjGR5qMImg1QW4it4k0wV0Bpd4Ea0xSj1mM3BMM4VmJFMWXG08vTDA6Qm= VN +Y1ZxQQwktPKQkBichNr8ZjFBH3pxDh3DNBA7B6P2dalpIHYJiCbRaRYvaCDJhy4WR+Qf6OpX5Y= Yd +8x5mvaIIIbzGTDVQjyPMr8VJUXHYozawwDgtnQGNgx7ncYoPIW3CgyzyQFzUq4wub5BZy4h6Hj= E+ +sBVSX2vEnN2JKYQfrAIeHZ080ClA2ayPPxKzYQw5A7YjUpXaw9CL3bwocmkyepzLpzqRAOJrVw= 20 +syCZjBlCAiM0YfMRaYYGGQJvzOQbubqpRgCiGXDFEjOWmKQ83QhABNpvkr4k5jxfJJKDF3UYTZ= qq +gFCQ8HVy87pFmiBXCSYoElwXbmMRIO2UiWknAeNCx4xrNozrAPE5PW49rZ1tOmVmfZJIpR6zG7= bz +NFpcVFypIIriyY1PKdYB28dbn4CJDmmCHhkosmDYKGsHaaf4g3AcRAsL6YtxjztkXo+WfgJGCe= nL +MK6H0TBqOhTaeXrWzh6RsBka8s0Mhi2rypsyxQpJhhJyc+6394rQg34kzRmscCSLy7hdne+9XR= ce +7u26fBJbsw5oAsOHIfdM2O8DnWModkUYhq4L97hE6HGIsCP4Fj0uRICuWQpFmdUdd6fL7jdP8z= TG +TSsLIzun3yS2VSaFBKsVqCD64zXOqcQM9KRuKhGdxh/SJA0MxNVFg6AQSkOKXnRdd1sXA7avUp= MP +4XEzL2EH37P5gVC3xha9Eksnit8ia+1hOmB7T0EMowKiUt/VRT+n0yYHn18slnidmIPBiCo/f5= kU +KqDqhgZEaYBWBpaYNJyWLoTwLVmX+PBPEkL4Tdlm+HwZZHxHkfLGbo05O4HeOGhtEJkaqORzFa= pQ +VYKYUsoYIzQgRKoCoxIAMCAcGI+JJeP5PrcHFAACTT4oTEhEMiwgkwqDgTgoDAfEYSmMw0iMoj= CS +c8g5yGwSAD1ufuHYbcdl6tjdUk+RTRgz7oSv5IuKWqP+/QHXPUSW2GJM5w131EWWlFd8aV/sH/= QQ +4rXB+k3idX24l5A7VrMYdPhHaGWlxgck2oefF0QGjraPCjINy0Ce/u3HXWiQa3KcwsUd6/YN6J= jw +a3U46klHmExL0kO4zO0sZmMgJ7i/4KLGUZdegWUJHjX0BOdF8X6/HNBRl4hVIjV5yaUEF33ELZ= yJ +dlek2ryMI67VvMDzrv/kJV+d5ix+FHbnE4/67frU36VQDShzvPZiuEvTvGLqIzgKJhAPPzh314= VH +Pma24LwosxEG6Q38dJieNOQMgtfm35pUvklAwq7t/Un4hHIaXTyfhl9n7TQqeKeU4VCEY4Gb3X= a3 +mb/DaA+Hxu6BnuV9kCFDh9ZQut8T/VF7HcFhLdGPmTrUahyR0gbplo1tVZ4E3ra5NQkbxpiBzy= Ug +wv08R5yECopnVqwuEDmy20ezZJPg31O3SkJTunB5XgnWk2iPrURlKqa6wqBOAMkOCBUdqIc8fM= Af +fpoYNq+Aux7a4g+72FZ/JT3UuP4hlt6jn1q9D5tPqQgR5r1w9cGtCtEdh2RmMmUv/lVwyB46zO= cL +Bk0NaupP8r3woWTjStA0K3T/EQ6aT0HUucqkJqc+IEJPbGfVYlL9fOFY35TfEEbALuookeGPG6= uQ +i1S5qBjuX6iMDUY6Qi9pkVSM5bF6UPEmXzPnlYqFmPVouhLIZf/Nv3a4/OJOhDdh+aVFGGmMOB= zA +Ou3ep/4BpAtV1U3FDK1naC1bPdiAJfsvComVa+FktQliEJIfXBPbDqf6PFHDgjZXVsSCpmloO8= 2s +n+GTTJmSb8oeqb7Eota1EbdPqZ5mmg3giF4+ecoGuCE+NehZeIlVrtcYdTFFoS0mY2KGTG9I34= CR +M+bwJVcGf97MzKSBKVnBwESKhhxUko/h1uEG11ArDI+QiCB55NWpebNuvuN6gcWaV4fsJnTPqi= rX +ANn/g20eEHQnI6ya53cd1rfMoNg5MNPhmKmhPaKQNQQLQA6CJDfwzDt0YN6PKeYs3n4E7GGGhm= XR +8bc3l8W2w8ncrXtEUjrzhCLvO3IGv7oNq5Vp+1KLUwIU0p2fHdWHuWSAIy/+H5x6iuKtDJbY99= hp +KraSfJoaXJKtVm1V7Cv6znO2McJscu+U6+4ET9cSG4dUHKzdY4FQI69tzMl4wJRFPYcL1GsIag= Jq +i7hvi1tPUZUeLe0z8/V5+dtPTDSK4BgJBCYp+QzEhNzm0/Q5dp+x1iwL/kmN1dYz6yz6IEiz0s= 7Z +mtg+1tSVIfgQX2MCzfHE3I5FoeQL6ZaQjTWL9Z7gZAELH7QpY4pLuW4cLadFF/7oMZXCQFV00c= eS +kurvRcOOKkuObqvxIB2U4ZSTiq7HoyMoNe1vpVq4QDRDaGlRg59ScHwUQgNRgy05kXBUZREn3X= yZ +JgmzAX6FU0Ci8Vbjcb1TAzYXUqOKLPQrTvOz2fZrdb7yO/plb6Y6Bb0nBqBOUFE6imeWajZd90= Tu +CGW4e20cWNsTZhxzRzrw/7aU75hrJUPEMSUMOz3DYh3+QAMzS91eKyS01UcG/w0AyECdvJyesp= c6 +ebDoqAnztzEcM2GQLD2dFDnjrhFCGHbwEB9zuewn9Ce82u9V8kc0cHFbsP9lsXjRRPhLNCRgct= HI +9et5iUmzx96swuAq1F1H3+yA3ltxVTzbvFB9TWTBBmKJClmgJ8IdyIXIhGYahGxhIuPLTFiIVE= mu +ZRzN3IhMHYb19avR0KUxx+mi1BUmbqjjtSTtnK7FdSXZk9o8HoHXi+HFznqSdbkTKs9PDqsYCf= QT +uN5bwhuonm+lhG6zNSWc9JL4Y20a7hFWKHldPOzVU7AzUQxKMrOSwPZB65lG1tTRvyhtIr9KbZ= Rh +0b9C1e60yaDS/DZevvUrcLmLkm23qmU+hyU7TofbpGHI2Fyf9UfPbI8OJiwTr2YE1EsLzz2tq7= UP +5wFmdgVyRn9L6JB6CD35W7pe1vMUxOUmkFexicogG1zQNx8v/AyvkO7xIDrn3OdYm8DSM6CrWC= BI +/LIdHC4RnwpxuOSQPZe63hmpqqBS5vye1jOlTgkwvShZGNNj87f4qgWw+hGYbv1uS4aZGVjVS5= Ht +WLmPfMTItIgXSmUDK9/fKnky3xUOqMb3qlhYkYJqe9jI50SkIm2tjKz0m+9/TmJkp8VufHKnIn= tl +y8CK+ArtlZ0rLxOYgSUTeQdYk8uaZrnLouJg3vagpYcNJqPYgzTT7eHcbHcfuLM9cudB0CLk61= uj +e/L7Lzan3aye5p06bjtLtgdY5hrNteL28Jux4L+Zg891bk9L6FadaHaIuGt1faFyeRXXp0MxQo= wY +Gc31D9JeSlQjZCA8TDUPAlSJkKf6U6OKHqSTCCFGL8X7ehbUoE1nCz3Y/M/cHrkZy1rzIdse5V= uD +yT/HpptBelZle4S+5DwPcn4ReIgQ0yL9dKBV6yr5LFMuDaoRMSOEkyFgdhFwHyFDEwejPwhqqv= yN +hHoxBFTORcDiuaq8tWoW//fkOUZ0Bm7vixJRFAmqB2epvUy1yLA59836HV9S1wbVml+iJrW3ht= wd +KWQURdpZU/pOoln/h+m07kiBxOdOGfH7ImziP9nyke+bsLgqvlZsvwHwMTnca29OFPVTJLx4ov= nd +nU8MAWIo3C75RcaQIWbGFIHeieH8KaP3lE0BcHSXjq7cGuNe/bXPtvx++uiMDEz7/9BjbyevXM= Vu +6mguC8A7DHqcwi/SsqG1aHGPa5h6HO8BOdpH9Mp+FaUvFJEkGBsLGyt1bxj/r2nRbr9wg4iKLE= 1V +fvJxH0gZDahmfuy5JORMG5cHprWiolhT3OMha16NsSRyfQ3a6dvURKYh6OjzL0KB5QjeUwuI1k= qk +xUju/uy9dhjsnUgyrUlHkM3dnMfY9cxVXkMOc1ZMOoZR+wum2kqCepYPct35druRvWYzpX9HlS= lg +yqtrI+o8eCO5NXAzYiesJ8ubeImcWmKEgjG3V8p8Cvl8b/JPgxI14VdQb1x37sYRvkgXZR3bSz= Ls +CN8o5lS5DUkGCY9xivf0tS2tosqomzCSZIWk768HqFxp4KdOvBvEpl5h2Vz77OOSWyE8LIheAd= FQ +zTap78HqmZ3QjNG8Jzsb6OPmovC5JAr7c/N9NB0cwTS6bp7guW3fk1N2Z+/gsTffx3OWavpRzX= Kt +QkgHyirDVenPkQAt2MZt6aLadqxKARr6ypShv9GqYev8SB0yMbDsbGXSMarH9dt32A=3D=3D + + + Y1v5fZuF7zmKBoBis1TKE9YLDpiI7KgtSKYGr8uaXMblKowloaywweTw7rVo81bCerCF2y0Rp= k0C +Qmh++n+H+t58UGcKWIgPoVTR/rpEcgvWMrJ5z4FkUu+WNE1ySL5Hlw9ioQvrmpXlMM1zjCh4ll= 30 +VZIhjXKF5os8QyPX6w7Ez6sP2f8M/8265VmeXR7uVaKSwU9FRsy8uWTZybmPpmvM9nAsegzk2E= qd +SwNSPx5rIMBpyxDszpfEgzo8LAGI+a1EVgCVZnt30JYrMa1g7N6AXD3nUld+HGVxuLf5HETRo+= 9s +DZx+byWBq8281qRcm5ArSe27/PSOTqm8jqcfDTMJhG6+57EF5rAQcUic60LRjoPiXnbK9GFRC+= Lg +Mk3yCsVLjzIAZ9KFjDMeXaNmAExCDmDYc2AoZn10vvqXN/2wr82DaJb/oIX8PZGdgzXOC8eLJi= /D +ovIBefjFJ3n5QIlyle+4CquAxa2wzKr82986gKU+3qoiIoOLgfCJymEBER3qTUyqCaUGaV3+JZ= MS +q9E8nJliu8AwLikfamzI4UrhmwTgM+x2JruTWLHTPxhJjfCs8ZqEv80v9cleyXWvFa8Xd2lM11= 2X +OeFbEmWY93FDTbBMHzwqErHDjMMntJIoIVhTrqO4ZGGawEHkybBwYt7wMpf0kPESK/ij0qv2Vh= 1m +9l+KcIEhmGBR+dDceBZhm4fBn8L7uzpIxns6zQQMehBaILlQYXHVJ402Jnsvc0n5iITAQd5dG6= fR +4Hk1FCcTg1csgdApZ/6rgNCjwa79xsVekfS9UduaxZxA1EkySUiwIZ01Ih1tnL5y1BTBFhNWLz= g7 +oe82cLgtusDzw0sWKaKygWrxHajTrGXwN2HTsE0QPExYUQ14DfhL+op1AQbbelAET2b/9A6EXt= 7E +7KQSPoNVkA/QKs97SgnBGg3MH6u6MvwavjMOOpDe0On4xPln8kilnjguUnnQtN6v0KUcjRT99X= w4 +kF/OsayhOUqBiZtYl8wwYuXd/ep3uHgydDS5ujVPvN9Ku1cPr/EXrHsYnUcXpCGJI9aqElzokP= LX +NmIF9iLO8QBLvAKbNHuMVdHlc/ErElofvCRn3Qj6IVbQxs+nTt26ujcMMR9qkkJn0iS32Fpkcz= y1 +QnsIa596hrbNX1IX3g+LW5ye7K1sW/eCtIee8fkJB2QDVPUWsgLYvfVKGfevEL1b08876zEeJF= OL +hlw2mUfeXktISvVAqZNMcRtLuof4APRgdI9lOqAVBl6Wg/ibm3uX9CKyCqwipn+GRPZutI/b40= M7 +NZhbK0n3b/i9v3MhaPabtzAlNHBesQYeOhs39DrixsQ2NnkrmajhB53FqqYJEZI+OiAQg2HiPt= Eu +46kAhXB2svMSeY2qeF09emI0dbvol3EsB/BcLI5+u4m3Hsmy/jNDaKm/4JDIscxsgxlM74J3jv= jT +h6OQyba6FtfkgoGHR1lLZF1CZm+kG0UbrhZuPb30xyEqD/fEox/37rmE9NTBWS/f57XxSSxJ8/= Y9 +PoWiT8j1sIUlvQpUUwFg6nmnzpA0SjAtFqb3GNAHvOPStj1R6mi7b7vT6e9dikJRLLbxZZ0cs4= 9M +TRJFAKnmxIAgvgPNjs1Uy4AlBOYjfsz2JuBahBJkoTWFwyXZ9v8OdiYeGaB3NG6/pEDxfHYpXE= 7v +jYYwW++kBcbfSW3tjKn46xDgXqd56iSgcSOHrP8cD2IbGgtSpgUiJqeCGm4YWzhSQqzgZf0NM0= ki +3vX32qTLd1yNgvzgra37jzC4ZZVyHSOMV4bfkhTb8vtwASym1qQcc5jEslPuhaoLewbFnUxm9v= k4 +qGViYtJvqVRI0VfUvVFs6LWn+70TKkbdmt76ggmyY8EAWPfEhOIg7OWwBKcH8wGHthfq6ln7ZQ= 2L +yiWoAZhB15HUhWqsK/re+GVpp1KT1cjwEoDqE21dXsjDx2m0SZ6RcDmSSfDRi0oQFK054NvJNM= 9/ +ln+f5/AJ9HZeE5jPC4lkskXPjMMolg5fFbftBlFrGj4uJsqL4CnQtr4gQgSBcooHAGzkjFsBJy= ik ++hhB6NoJPX4uX/ed315tXLd/qBNjxPuQ/mntdayjPqEKMR3N+p9uyl4QBZjuOuwp4MZj0y5Y6m= A0 +7UJGX5419NAqme7V7TPyjK/0nocG7X5qp6NKWl+iYOR+GLhF4t6MWd6ej171ya2LRemUioUl2Y= lS +3UH4TkRBQqjWkpoA3DpF6bvx+Crnc6u2rCVSSBCCDDoYC6H76zWkUKKyoLi2kStFSdVSI5vGLf= ab +9KB2XxRd3eWZYyWXwYvLfWx87p0YxAqgT9x4Y5UuhnAB9Tgy11AST5Pmhic9PCwEfVWUabyQLn= 42 +cHuXd9o/VkdjZArvmUWSr5FUupDRL58PEOpwlGGzgCf75Tge7Yifi83a7aO8qlPdKLybOOc3lM= +3 +85KV95Pj/Mn2G8sjE43lId2XLE7EKTrXLwCkdrmfTykao3Wl5nNOVoIMo4YkQE6RHWvmpIhMs2= A/ +UpySnIFAupJwduxL3IkPyHZ+g/UEQnSh/BKXr6y1aUJkd9Z0OANNiy4E3cwtOLxNbt2RqJ3mKQ= AZ +Q4LusQuqfuwRF2vH6HyWiGKHu0Hu0VF6wVsUvB4Tfrjj87cyPyh0M+DmbtYfG63mw6FCTg5v0j= nM +nkn9oSQti3SIrBvZrLv/Gi1r/F50QosCuvJKNzy84WJCz9dcyJhJM4zM0D/q1t0Qqn9jtiSww9= 1i +HRj8nzgdZterRnirLC7iM9fQ3bOGd+hJmehuCNiNMHcXv7ia+mCGTHalPHgbYHFFlR9sdivTkB= M/ +ima6ew282ewSnTWlrWsbpspzTvjRweX20LwAwNo2KzjuJWvUj7b0cG+hzRyrbbiNf/hzDf7xu1= dE +6T/P6gXf+bzIxWi73UDJKTLpldy+CNNLVPlYb74Q3IpDkF6CCUb0fyPpWG37W4DSgjaRhwaL2p= ab +28lcqngYr85t5VUKNEho2r55hztRkMtkn0Bt33P7giE7wIZq2+z/mXxybAyF7BcAJGZMY+IThf= A9 +rGm9fqcfibZZMxGUPekbfMJd2bPVXP01lx82biBb/j7QTcfNDSml9sBABK92A5khGQkH0WYi73= 1S +aLWIKRVPpO2kxzyHUyxBiuDrzpxCK4seaUXGP8+GbNJxlCp8FEdMR+Ob2GYu1KaS1plZsr5nH3= dA +2JYI0uNf341t+no2sx1J/Z+OLRO1pFvDvtRq5K62xbEVrjNbR3OzjHgS4TzpCyDsg8TRlebjK5= 9m +ZOT8PAn2B0f71AX2GJk69GI/+IBmqT/Qrh4L9WOcHYoaPD5AwdZJdEboeyKtGQeNM7jIMZroN+= TI +0Kh1EeIoIw1CD7RDlnG7kZCQGJE4ye75CsgxFHHEpqNFrcIOjs9gIeDYwYUNQLDmwmKaU4/zvT= hO +MVPBWP0kOxRzlYbS82LIkICARALQd+aaq5AJ8hr1oUiOcUCdudWKfmJ2JMKtwUGf2P+5BDjldq= Tq +6al2DbcDHUnEWyNagj9HA7+39jzdFywTxuVkDLYZFLKDU5YqdGz5GRLr987HGzcUB4h70yKWB2= 1h +H6TahSh7jyG7GdMw0SN/bLYzIOtMDGd+szr0G4hZou372f/o2P8vt6+U0u91G0WJls3YUk4G0g= EC +WxzAqv0qUeeNw1Z2PHUGqb+R/ck8+5bafw78lj5DnnNEVqsUp2gCjNJ/FJtKXXtsjePbnJW0Jl= jO +WnkRk0OwBL3XJ1On1JAdpKhj1kog4I1ofI91fd/WOiPdiC3isa6h6uu4crM0W4qdI5YWKzb9A0= HM +J5xW6kfsd3UEuEmn6++DIv2HmCPav8tnbPCtb3hmubiz0vf4dzXdQNFvgHYbB1CZdKeg2iVeRx= vY +OVurY6w24sqtqVj0CFcJ1WPbcSohwhjjo8oCJ30BxHPpY47XcckQ4BPYaYdzvZYogWVy1W3C3d= Jm +af04OneLcz5YhuyaZDMdUOyt7bm8rlkANCBTXxVtayCocqMCPj6li4GzGPGVdn8S8fTuT6++P7= 2G +/OE1NtxXgpTZ9VmXcA8uJICDPaaAti127cSM8csreU9TrG2W+/E5lbsYnCJHBHvOMtD6/sNXz0= B9 +itXBxrWiTtZniwyb+pLesoCV53WxhhpHIc2XFoH7eeBfN8m6oqpUg82T8nqqtJR7V7ZTD7NOry= 2N +a8G6+eNNlWc7oK037W9dPhaeLQKX3zD5LS21dFb3e+3ZWpdqJcVVtUWHhGpB6E+78SJjZZ3wh+= Ki +khJJ59EWI/vsnfGgJ2hawXCy5Kk/zm0/pBTtCP9SHD500eKaZAIrAV0rC/vEVCC9bIPHShkeq4= Lk +GZ+G7V3UKkSg72k77IkiHDpYK/DOHlbiis/zHMKT1YEXmTZ6iJfvkCR4HfCxqPBKBeEMG68R92= 2e +NWY815041F7ztHK1hVNFDk5MSaza1Q9AhajX5mn5MWE1/vpTBxrKUther26XfU0nnEAW4gnIPn= 9y +jjaIMtYAXVlbgOGJ+Snoy3bwJbLT1kig9iSMDVF8BLhhSHb/Klz5iOUGcadwkYCkf/W1fDz1vI= Bk +BE0xARP98Z184RCDO6mEeOER62/uJhZxZTyrqQJzWr2RhsGePmwa3Cr3JgWODFrVN2sQ/oIIqQ= 7e +cAtuddF9UhK5c0Dk1fTyhe1oa7jG3RujXfjNS+RSvG3ffB9jI1fbhReH0bgfwOO8QaVfR+OYII= 5o +P2No5pCWYARJ1MUyT2u39tXWBetnbOw3vWYly5+DRnLZroNEP4ZUP5gv+64UqrtC16kuDh1uKm= Lw +vBauf7Vx/ohlQ313PCD2irHDjK9lbkNAXGgP7jpoXslMca3yGVzVtuP3BFsUz6eTacWevx4HG/= Cy +GAlk+NjGSv/KXTQ9T9bdOv9RkFsVkFdnfDdEeDHF8Mpj27KNCuw6MLne5jDs4D/ySNu0trGo5D= kH +H45vSBU7XmD+10aT0vSnyLu60SwxabyoFpjZnQhwvxlcMe/Cl8kPN/jD2/I9X2lUlAEl7iIDrb= wL +moCLEKydnfTHKknaOkDEB8yNCkRmuNJixu7kCg+isy22Q/Hk86Tg7/O/I56cGrtKlNYbjh0cYG= Tf +GnfmKTDFk2Kl7maCrcjgco0WKZ5UrNEY0Tc5IOKpaWtumUrmTTFRgxsn2oQdG654mpxvvTiEtg= u9 +R4CExi3Q37YYrRUsYiwR9kcFG4yyjmw3pkv+nI2Ri0NWkXWweRsJ+E+/DcVXtAloB0eV60v3GU= OP +tHGXTBWcbXeh3qTzh+6NLn7hFHQcf26mnu7r4KRBAZ1tHt4nG4JoYYdBgQKkanjFaVVQKiiaCD= H0 +oTjP9WYD8FZfMBFmKaiO3Ut5Kt1vxny8VqPtj0XPtOuweCiztYwWod7Rb339gml8KclnIQ3ARr= Ss +Kll+OV7PkGr1StvE+5h3ldk4tsOmKJENnCbnxDINOKqOrORMBM8cRZNXcAksLrKuZQ=3D=3D + + + 9qShtA7CEnXa25GfxPEfVCfEWkPqJUbyELFegbw1aGp5jyrMGu44VBxbvIZgscS4kEjOSI8tI= 1IQ +I70INlUcIOmJPpYiqhqEHrnRhKbrzzgh+2t88Y7pDrHxRjA1y/VlJBcODXV+Y9u/5T/EdncqFi= t4 +CtG6M5MwizwpJmWYV994ShOm2EJdoKmYnXA/7hcbAW8Js6REaV2vsEFuPElWrCulddarYh3lHk= /u +vfKfyQOUGD4T9vGkhJ+Wj/XRbTyFn4Sd8HjKKmNRdvXdHokGevt4ys8Jqwg0nnAD8zGA5/3YNv= Nd +NxDe81l9lZ+sQUkJrydVe+HlrezOcbiGQtA5vZskuF8vCiV0sspZJ5prPJGt1lwpzMga0qUhkW= vb +igi/m0QD4lNM4MwHyiE/VULIJCFQRVYLMT/0+7B1YVLLEk84Y2rM3j3Jg5dMRZ7Xcc6QtRVge7= q1 +XmYNlrGwRrmJlmgVYD/Vp9rwjAzxShJ3s1vhqoB3TRnxmM4+NUwPYhx1zCrolSK5dqONDi/Wtw= 93 +95NXV81sNFX6YDvQiJnVucNumNHZ0LccF1QkdSUTt4DSi2siixe9dNkliO+uUkajchGnrsv2rW= SZ +vxOHdymg0vUZ6NoOz2UXQpC3RjTXC0DW7NtmldeV8JUuSq/Y2lKe8M761qu++d+NJHOlHRtaiR= RP +eNerpSmAkhCg43a3YzpaxVJFjSM6ht8cNt1jBCnzzrXXWJAMdoO4xUOG8NSSGJwtjkfomPmUR4= Ez +xM+8VVpHM6WLt4TsLHyivwJVPrvvjMJKiOa+bvOaZkWr5+6e2AvONxtdOZ9J48PmP+XiDp66Xk= Fc +yZN9LhjcqG89LZT9/b6M9DGw4AXGimqUdVmgFD9f+ejvS4amgL6ujI2CqQklMq1vMiCKWhOjA0= da +QGEpXL3lD0wVQnmdS0lztAJ6GTXx/OqqPCtL9XN2t62T/x6IEi/XfZl0xHrG5JZ9XQVebBYcEG= SG +Wh1zTUEZ3E3BJiNtpg/z0IRY+kMETi895DI145eu0nHKmWtQtbTcSQaZ728sIIabPYwjoVV757= LE +WFlHuUzFCS8kdigVS7P0DZ7cYJkpNtkvSIL9OyEz0LpbMLATDI0IKZymIXR8iXNwjQf8s3BGC6= nr +91STUU9OVu2DuCO5MEs5RQovP4RWp43Q4Gu8gB4cBtZ0fpQ/aBF9xi3iyifeC0vGyorl9VHzMU= S1 +Dsvo9r9GYeK3tHGNBeNfYJu01cFlKunFlS+rucnxeHMD1RyqEOyi2P1m15XzE//OEYRpdvFuhs= R1 +GKj0L8WzO27Ghs1NlnWKxse/Ooe2ErlKjbYw1ODfnXnxu4IlUf8e+Au+6Yynbm5KByLwvl4MnW= T6 +Mjc5G32W3XlmiH8pOgkTQjGi/s1NRjX4F8HPmRNHj/6l2ffYVv7Cd9qg5qbxJKJq5FRIbYd/KY= WS +DDeQoQw90yEUdFn/slpG3Ow/T/9G9w3Nm2FH/Buzc44voTyVT+HfZXuRbXh0qn+Di62dflAA//= pw +6sQKnKolJuPfQdjHyfRvaMqeQPybjn8YMqoljoZ/t3dKmerfg/AGnlgFOvuTeDWb03Do3+ViMm= dl +Bgz/qgO1V7IYl7U3Onb1ygcgCeZvVui6oVt6Fx4rTA0B1b6Aaorb5qpN6XwtY2NbZnJjVpI40H= s/ +vebko7pCMpYOrw22EFdq8DFldbDz5EeLZeHKTTeQlARwBYUkcIJcuYpxsLHRC/ZNfDGmnvH/e7= lh +oFMgKdEK4i2cIRvKZcelMTfEi5yF/9CaAjMN3aLNAzlXMANIwTQd73djf8Dz72hF3TKfEY2+uF= nS +HL0ywa2S/h7pqLycfj8GF2D6KWbaeffLpjRP9qpVC7j6+yf4+nYTYjkcfArFt7zVD8BKsCZgEH= S/ +FpKR57WtzhOKKZJBpTqBTZKCnHGT7yglKK5OLCyCOSvVyuWKOlRloNxaVGhAz8n3Ydq6FHhCZU= IW +g+6nhq5SGnrrfbjpYWCHrzZXarhGyFYk9O2ZXKljxnjTCnkwfMY4QJtM0GuXhSXJa6moXD0uGM= Q1 +iLCuiIcxAdORXz2AgEi1QmHAtxIQzVZEmMw3491CNowA8YKo8F75ukmUFjh3uqx58uDgiWxDM8= fY +5cneM2A0Fxjb2YVi5gaDb04Ix/24wBYUEjv1fOFUAoo/QAbfmhwYa0U6DMEAhEPbVk7cLH+p93= H1 +6t1BvTs9sUjqPZ9e8GXDXai3t+TDdnBCL2b+BvVGfzE3oEp8Wmeu/mqyeFuDAAQlRuqtzo+CGJ= 9L +2QGoN78v9t1vk0qo13VOsr/9ykvq5elqL41bROTvTrympifFYQ4qPohdZSIRS7H/1oG03t/vNb= YZ +U8WHYyWNJnpBtJ389ZXYRCfOuNnmF3NhqLxMtoEZejDdyTIY3x8jBeFVarMuFRiURNotTyUuA6= ib +TijzopftrItIJWKWRMxx20l2qeoolmyQfGmDUsuwvRjLGRMAB5TRj06bXuhKNbTCJoi1LLZgCc= x+ +oIPFBISyDMFObjl0F96rjihOHPWAmoQfOZ4TxcuV7FE+FJ8ZUVoIzz0AxBEnsaK4S+SuIsYnwt= XQ +YB8GLXx+bkx1GePqVfE+lmO0RzymYuDNXo/75pvyIYgEAVqOOjlXEeaKOCbfCj52hZ9Y3szXjZ= Uq +HiB24PwffEGaYpoEJYIAnBO5tM6I8uWXlDL24Lzy9SJc1glRCiM+U8jj3d1vpkvufxOUUV4II6= pY +/55BVBEerB0nzNFrO7nHeox76Jpnudb8mJxlqv7Dv1ev478lVKpe+bh6QZ7xb1SzDq08+Tb3zo= yN +q1exUDn4zIlT9b5Ru809KQxQ9apyk64hwjFBdNV7qEsG0kTY8dWL34TGdYm00VmUIgCTd8JC48= RG +0dDVK3di054zNql6/5FdQx8u9up9LiJrZJ0kGAulzq2rd2LR8eo3Az3fZXooo4toDrMib/KOU5= sd +TLRV76k2M+1oaENmPxRVGswt/6yWqzxbzF4HZsxfaA5Ee4+oNxcSumDjcc+dc3Rw6RuXz2F4fP= jf +W+Tl9Hjbbw+LxkCJvpqDMRYx+0kCcvBH7gajVinYJtNe4XMXkXWriXrS2RCxRJ5+p2tT9BVuD7= on +QFvO1agLBJ2IKzxKmxQF7vNX/LO9NG1FV4i6X8bimVkm9kn68p0/uox0UGlmejlizEECLXpR9Y= 7k +fGZwma4LGqiERpD/cxgnizAQCnFfviA/XbWLdBGDXA8xS5pnW8eHzXthmZnQdiiDXVbYj96bZU= xE +SOLDkGv+Mz+IwDYGMXWGxNCC3wuNhcQsIyWIWo6Uf7jjlXe3xlhh2GgORdD8SFDzvWAE51LjEd= Qs +cdjIn05GS85J6CBdemIw3lWQApw3CE+nMm36MdIaFJhg17FgSe14IOC7Kwe491jhinen8uU2gW= fb +w/u7izWvBoKV1A/HdhxnMLXH/ZZ4101oegUxiPKf4ne39Zjn6eKN/d3FnXgqa4CgBYTX37W+u0= 7E +t75Wgni3vq1JCru8ERza4IzcboGoiXdb1VUXM0vtd5egb+W/t3eGoNieKxQDoSRT/dwrYuvtGw= Rd +KTBoFL4HweYXR42FFEd+UQoUAz8owBmUYVH9FG4uZfgYHH4Sryb0KF79dLf1pRGI2UiskmcssC= SQ +5EpM7ZsL1dAalq+7fjAHZjXeMR1dAbD7lTuzhQXa76Jr8URq2DO8dmg8fUBZyqx7/hJk2HFPH1= yD +yTfE3XNpgGM26sL/X1h5GyZJJYOjfFRNz/BzCObZOOunmELyKJoCj5UnfZIek5fm+aJgMl4qEC= 0q +sM00d+I4ViHm6GMEnBm5WW4kFelWjGs+LrebgRu9Lu7IGcJVRK8LEm3aJ+tK1jlON5FmGEvmpk= WS +oio+eOYNoeuUOTDe7Z4MrRYEaLOKBC6lua4YrWg4lms3/5651U6MMpr7aZ2nu8IyMs6qMYhc4Y= 4Z ++3C+F0cqSotchkAh1RfyMuG1UWVbuK+VDPCONNYylizlmnAr4bRqvZQ5JE07aqHA1TEBCA8XHu= qt +ex2V+TcxGzrWIqWVUdGHVZH/9DP0WuT95GhSBYUeFJNgN2bilFtaAWNFH0JJS+PY1QXihJiaJf= PG +KtQSkSYMBSyEKgxARFQawzBLk9Y0/KAkdgqC7kPAfjAcCcQbkH8MDRrnNpAoSp7mlTtZJhzHrH= eU +FJHxV6PNbRZES21icvdekrXKATHEt8kk5CvnAzRB73LkRAfuo0e1RSytOZeuVGGJQyUPRbgqvT= Pu +B2iUwyR6GkNMDivXUGUDUAiqufLZZZEyY5sauOqRmOx9BZx8CSlG9gy0WiJadAMUBsX81xLD+N= dS +gkUXM7QS+1UkpaNLPabvJDXrbOHLKumy2Twgc3R9nNCSo5vu+7xcxf3omtBKlAbEFB19E/w4sa= q+ +J4vuYl+OMUc3jjOYUEfBUP06ujF3GTKLLs2o7mX1hsQ6Ny61At/JDXjODzpAq+562spractYyL= 0y +76XSS/HppYbUbE/EoSuufuFU6YzD/IXYLCKBVIy1XP/r4Cfiolglnyr8VLIiOz3s7IfBABX7z0= Ab +DtEKD5IhLMjZW9EZItNQNS7C1r/lz7eWDHFGeO38l/n+aMpmmOrWUHE/1/7UlqsR4GUSl6KG6u= JQ +yw9FWDV/kuB1sZ8aKmMm/yhWzjpC1qA0kCcEF/6+J4ba/ZjXBKKTBXNaHH6Posfkjhe9uQoo6d= yP +7CRQ1b9+jfQRIPadEgIe+mgAio1oeo8QTgjfFtHlvUUxPRAJ9QEeCS5WWDcuwJFtbZLXafCXGJ= HL +axsROyEApQVhmg+RuSNoOHO3ulbJaQnfG09WfSOCrWA+F9BfyCnqDTrS5Tq/HtyEm5A6hyoihy= lf +BqZSCwhqoqoIcG650axTiwgs0dYTFcTkLKHFPx5rcX0yLqAZuYnSMedLG9EEzf5MHXgCUYCiTd= FG +Yj9A/XFchpmhcXvhvVADHUzZXY2nysl0M4f1OzdVBg9dpqvIrGq7VNlCuOYr0/WeN5sf3+/4FX= JN +m0qXjQe+h+kq29i74SoNIflguoeAKgbGlKx0IzTTvbxZBJclIaYrejVuCS+7tSY9qyx4dL5lZK= XL +x4WcwXRlX9sk+btUlFFAHMzI6XtvqtehG92bxZkgtJjE0Suj71SA7rK2KmXew9yhOZfqwyNHR7= qE +eK4M5T3LYvNm9GRllIcUfe+LI/QcI1AA/7gqncpgDLpAe6ELBwPUAOshatDkGXfuGGZlYLGw3y= vg +lopbgTHqTprsCVhC7AgZxrhAxNd358pwYosAJsSujnEyp18JMgYmOfHWVpcqi+dSewo7DaQVRK= iV +hKEhZRd+oCvwBMQY82pvMtjWK5KqkYIt6s07/MHzvQ0elsml2VDx85Tgo27dSZ1ysX94C1/SeY= AU +5dOVfiiIa7NiqL2PR91eHJnr95Y4PZDgzfESwAAiq//GosNQxWjh7j7u3PJE5ielGA=3D=3D + + + lNZhgfvlCqx2zcpuP/sV4Lvs+KUF+xoIp1avlQqPaK6BA8SGKwZfadbEpEnHDBjIweENItiZY= HG2 +sWI4AB9YtZsHYxcnk/UsxPzfFi5wDjobRF1Na4bQHleV/qIArnnKiT+ILGYJU0GE9QbvO5UOqJ= Hy +N3Zp3OYl9nKoIOhE2CNQ3NoMw2AkymmkOEitZpBh7cRbLXt7WwCTYSJ97KH8FFp7KVD9l9MKw6= zs +C+GGjCgL4ysEUUQWv+S4WU7cjyt5FVVenO8yC7e3ZtJiKTx9l+Qow8ePdX8BWbcvVTQiQmC6Gw= rb +ngJSaLnCD6s6ZgoMjQX+NQ9joNT9mP4Jb+Io+HHzXQrc1WR8x/5DINiCR39XphiH9y+DbREWu3= t6 +kuZ6ZvYVF/9+qS67wAXCB1krJajwKHIjXNEATg7J9xD7h/lwGU5KRLFrlIVbT88MsegXlc0Crm= 6G +knMycC2qzZ23PHi+GOR4YcVjyDmcarBTpxQXw5E5Z8dasD6Xa3OpQAcWqVDbrOYjIQGSGPmNXj= nT +mLPJ4iymha0dYuu/mMxrR8FjGs9RFitVtvhCAoYYp1JG2RRC0107FjKbXTQSTdzwegnj+c1esT= +r +iClalvcrmvauN9NuXvIuY80D5feYdKYck8296OaAv00IauMVU+4Pl49kYQBD01TX5X7tmWFtgN= 8L +ZnMvTarnzxltgmXadSvd2BBZIJe23Tl9O8oDOVp9V1OEyyIK7cV3vAtClK1TlN5l/cnJYg3Ju4= CM +qAZDAAKpKq5aH4FtRoPjHzIF+fb14R+r99NFATozbTt8ktFb5yIBu6hh0PHf6wl7fyDXLRBIwV= jM +gi8i3aYU6/YkODlZDJ560/5PDf5zOK5ibQ9fvvqzbwXUdCs0ulE8qChZC+cEdplT8l8rzA8ovc= FI +s1zjEZFzg1F7mWsnPYQnGHPLLps1zikWz10/hgoAVAodSksvMN0XiA9Ltngpg6BbIsYuSDZduB= PV +bLe8mo0YFGBX81NJpCVI9cgSD04XoAyySZzQtzhukcgpA+VHvYRR/VLZwQZ30iboekar6AwVvz= G/ +ZtBrZGBNWbbTC7ECn0xvGe7msp7gL2sqvSy9gMT62aV5iRW1jHBhUEGs+dr9+la90rIZkl7BrP= Cv +OYzBNTVe1A2JN0buGIcJVJPb5eaGY0orZcAvsfW73ssl0oJq4ZfJzGtquYGdyCFSqxi4AyqsiA= /9 +py3ZZ3Z2FzEgD4+PFH3ElIziMpfB4MPhEM6IET0cYBZ6Jl/PxcGqaXgFRPSIZNHNRr1uxGnAR5= ZB +Ch+WJHJaM3ZhWftifPT6VqHa5FiWjU+uvYjhg+urYZsAWXGnbvWW25UjEQEwoXMLkZ1x3zNSPT= 4S +UjRJt3nR/XKtExXeG7/wZzk+FJlP3cASvWi7NquQYnyKetp/MJ1WCwaEIICEwwlB75IGBi1514= ru +HZl+WVxo+S67pV76ywUiOaiIubti9k6xZrQxRYFdP+6OtwCck69fYFX4tA9XpaJnStuuuTx3C1= +z +Ma3Pjt3IkWewEOGNjEEiER12wspgAUGs/V9FpxrhTGRL1ZLXZ6sZq0i94YjMiuA0hK4G7+KhSH= cV +UKGOy1jYNUaQt24nrFsNbSTUqb+oEy0aGNn3wDT/nhkePx3YTGy6Yg+wV6hlDGcuQ3/Oyn3KG3= Hp +1AYHiMb/hduz/VtF5ieNWNVWzI6xRmCJJi1Zd06gCEdCgPMlQXb9hT9uuaUIou7EhIoSSNtl8W= gV +BAE3a65mOfOlz4W5EoA0Gm9T824xv1dGX+Pdaz9O+EC4VktNEy8LwOcdHQEBjzp/Eac1WrxS3i= d4 +lsbxIV8AmMGunVCNrM3rvUpMeX5CAIs5K8/Fy7QvNtepf9ZJBQY1yxfvTuwkdS+PzxwH7ilceB= r2 +fkhuf+34suX/K/yeYSlaBPL8gv/FO+nPbWnA2K00jBTJ2SVXScix2UV3GvNKdgqNZukOPBstBR= xV +Y5ZHtamOdvcjtHMt1jHEaK4252iq5X+37seG2Xg9YhHJwXVerALPe1fB1DIBCbFT53B+gNLoQw= bw +6xMLIMeiHZrYDnn19+Stt3iPmniCPXFwt5edk9pBx5GnfKf56CQm/43Jvx4F85aaazUjMP/avE= Vx +ywNKbnkVZfkIn3e4Z7i1O/ABj9rxpTLDB1/EYpgrkPpbNa+30JVsQfV4uvvW7bVFBMImCT4ScN= 8f +azoEhAaaGIE0v1jnLfSKkVHfZ9TD6cPjxqyeJ3KMmrHhChInHqkFalr08D3KwRcxzZThKqA1sz= rj +DYjHH57LikyFSvqNR/ji3DMoIQG9O6ZUDXz8XwxeyptKA794WimBvrvsIUMaJzPaCV4WojDn3M= xg +uQ5/RjJn51mZ9AXvyFbKdKPLhE/XPvdic3BOpOTso7UsxtT1ea0bWZGCP6+pZ5POmdFrX80kVP= Mh +PhkaLNnO1b3pAOu0VAQnJibaWEolnHRgN+nfHWaAwCK4MBWGkR7r9NwW8v0iB3m01fVhas8LkK= gB +3F9WMCpZglrnv4mZHbcutBmE89zLosABzOjxDIUiDEVB6UsBmkSC8bis88xc9bKiQQNs9UZz9m= De +iIgmG6Mftkqid/NHO2CpRw3T8CbL7pgSE6bWi+ZGsDp+F3lrGU85BXNWjOJboQGbDIfU3yWRZN= In +NLiQKuu9RNznw4NO5vfrmLfiaD11e02Vd6uziEEnTNOSw9ZKKzUdCzT0CE15zfF5nyPhSrH6UL= WQ +gZdK1NsCpEO0ThQlu7G7QsUNZcEDMcB8+Sz1b6U7q4N8wayEG9PJybwewfVNlPMa/+4A824FX8= iV +M1iHpxstw0k2YWhLM/v89CjTHv7xpgnR13UMv0nKDrDGYRT7sRm96oPON9X4Zu/MfQGsqr/Swd= w7 +DUCHUU++5aXR8qfZd8ukpktPYboqb6RYfx01g3YAwlAwElYKRrOnFO9omIEwvdA/WFikgNvbNf= DS +YThbhWlAvxBXV6E8xAdr5vHcY0dfXlWL1xCGPWQraO8okmk5WNhSq4EKHibgPdoQUTlhFowxgS= 35 +hmhXgK2MdC7zZCabuwfrwk3dZQEjXwuJSqwEeVtF+bG3RxaMCN9KzvE5Ih/izA0H/Xg6Jm8DcF= D/ +BSJ9jf2A5H0HH7eJlvyq7zXejQylWdmlYujr/OxmJgh1FgjZrzCMAvV2pJsXJJyw0YsRG9dMCV= nI +JmuYkKsAJr7roDIZlC8YrpgKW6MC1/qqxyXRzJHipp04LemfkXUl+ttAnAKc4afDvKgXKtXV9L= 9+ +AI7bmBKqyBaHTRA4y/8TUhJqxSNAkAkx4XbivlEzuYDe4GDiV0naysJEUkNMKU+c0ZAvk5l0YR= t+ +JbwntBBIDdwm7gUbQYWbF8oAz8uwDyqhBIQag+/h3sUltqZ0nwEW3/PPI59H1R7JENsFh6J/1E= cp +gm3zM05gGYw1WGsBwHh1TtdmWzMbjKUJLMdpetO0JEZMaCZcIvdIgiZQgsqBd/Kpv98bVyBWvo= th +WtoPM6VsWyraRa78Iz4ZWYyQ17DD27bD3CE203Ly6OqfXQaWur6MkGZICLrJtT35BTx+SGnjUV= oQ +ydSgObcNdhHKHN4y2nhnQ7O1c1Bu61/0rKKSC5qesq3PB7whxk0FoGr9yccpw9aw44yfgfxsC/= nL +9MYtEay9m08Rkz06Dzpc+hPke4Z3fSB8NXytULTlSg1cp8KYMQnU9Tble17Dg0ORAnigx/Q6Fj= BS +DODNHPqbhWSmH9/Xr+SMqfBqjNwBIHABOLzPJIXv54XvGSIkcJa1AyXSYO8qZzGrDi0agmDSUY= Au +Swu5a0tOJBgdGHnbVngN5JS6C++ZUj2S25z5ivEnHZnyjLHBIh4K+vopBNT831D6Gw9e9QXVBl= /E +Kr6aD3N/oxK31XdEkfIXzEfqbu/jJ+ACpZYP38Mm5umN5P92H++5XtrVe8JQfRE0p+//WUBoKo= sk +ieXeWnEXG1uTVTwkdkdIUGdRIpaJRd1jLp6UvjrKs6061lfvYcL7Cm3/dSRev67bLlKZJ0jHlx= x/ +UkLPqx7aqbCZ/dJOlJiHCtDY4BjjKaHAW4gMusxuE1n2cCnAn9tszUc7GVZhk20AsMDklmrh0d= 9z +YD3ivrg9vJdeFmCZh9SU52PF1g05G4yEHfEeo0HGaLZ13aiYaZ0HRTLhIT2HNvqHtegr6TCMNq= ui +d2di5XspEB/4v7RMGP/zWcrA/U7fQ0YCxqY88/hpZ0oH1ESk5msLSlIuc3LKMA93LmiPEv411p= 2Q +PoJadq3B+Q/KLU8Zze7l3FoRiaWUaK/ZRtYFIZ3TLYeTdDcl1JLpkulKdpgVayqX2SUAKnKFuS= Qe +lwxXNhjIHzVUSJmgmU2wprSqczOezlnRIYzIjSuwRSS2Cd79EnjYANfrUgRQCy79KSMsz8iv/r= be +zqoGISyAWBe+ghsjbE+lmfX8QURlkqV1QS1hoQB5vuXf+dVcB/tAe1tSgeg5rIXu5vs9RD2vRt= FK +mL+U1BDmDZK4JEvKpva0I/dkfl6k2qwmSTkvGRWAznXKbaYHcvZplPNOOdWlTvVOxPBX5lCPhi= Ir +5yRY+O/oCKiuQj5ZUpWuqsBfIHPX4e9+9C/I4t5Twr2aXJVfAZxldwVnnxX0MRa4wb+1U1k1Iy= 8d +KYNEBBz3j6wugRsuSQ0JRwK49dAiTDbASqtLwdgUTT1UorowXKRvD8vQzTRnrOH72GZTLVEfqe= DV +gkgAgZ9vQRPdyloVMF1pIktWPLAms1VpN9/gajXcBUTv5vg4VP5noI63pqs5Ur33zbeV+T/8ly= vI +JUEzV4NM+TaT760DRKZ6gR2X2JMKIh4j0H2YxG2y0YrOGKPDcT9S209M1jA4COzwhJJ0blR6x7= 1N +CqEYNiSG8B0HQxgyA3T6MbwQkTA0QtPBAKcGVl/c8w8sVhmWov4BDMYetiPW8OSa+z4qIoz88i= h+ +JcVUGES+IooBtronU5lPMKAyBqtdwV8LyJbrYf9iAQuD1oZVv5FHjBU6FTdYru1JuLxNULhHGU= Q1 +hUlhBHYSFEN7+2UkzdMxjRWu77Iv9iw8tZjDG9Id8eDjXUoXQCwLFgrviVZoZJmletqnQJxaTT= VR +lZyglZynI1KZD84X4h1J2PM9xDoVcbeIuh15xc83eYSAykt5o6nPGieJ1AXz6b4YPYRaOamrTH= QN +EzRgCMsbNcK3j8SvfmBYZoP8oSUEjByPYoYIDSf2O/+sq3qS9a1m4fKZgkQIX2YfuJDWd18ZOD= 8P +MWHx/8tdFCc7AnEL6ne6Mr47GGXIn0dW6L6pXCtV69hg1gYCd+ONm6UCBdo6JqOGU5i26j7kSX= Io +HtkZXvJF/A9M7M9envAA3d7aEhBBo5xVh9DN1BSFhrNfZ6P81PbsLvjPc1i4IfLy+8mo3L833G= kk +84i9HqkVbwtRuWNjO2lxaE66z7GOCot/CvOEmyR5mYfoD7ttHPOxcCBLg960xC0peA=3D=3D + + + XpfkGCbCCi0PAxDRXzB6bVjtAqUZFRCgE8C2W/7QcoYCrRCalnSrW6xIb00nNanF6g8I9VUG9= JnR +UfZ1i3azcz/addlW4OD4xRSphiyZFCcRhth6fgHwCjNwZg9mwtnVvx5gYy5vmNAg3DFvOAvGZg= xi ++wqxHjDvJzI4TXqoU6GZhsu9bU0Cw4W7HMhMXhFnFyAZpaPKUe0qBLOCml1UZkbtJKozI1JnAL= ux +7BtTg3iQ4wrPRovSS71vspIQ8//yqLq2TucmqfqLaIxneGQcDRqsr7xtazi01EWqa3/W9NcGGh= UO +x8OLHPolodglwY2CrLG9ovB1gN3InZU1rMU+JoK18P1zM0vKoQY1TKihSrAN9fhOcfy2nAxFuq= U/ +LVZJSNeAEYbRVHF43dUoRT8Dc/55QNgSJIDkOiJs9GOSTgIfV7+htBzDhcnzBfScXXQftDV9CZ= oR +HuD7ndpf2akEYKwEACSwvlD7O5o6K2A/cTcaWGAtDGz+1UDfD1bkn7WbbnW5y/LrpUOTZJ/iNS= xb +LbdMXJlxR7etyxIPeAxERmBjAmekSSkBe/mD95oLIPr/6lE/wUTBrwemeSycMVBVEzLpAS3/U0= 0j +GiB+kL95/F9u8kxZIDcEU0oBMFBluXrUKXgzhK4RJjxhzX9cqypoxWKZFNtXK83AgzivIYOblD= SQ +snJxLJhDQscCO1mFMnWCPQNlM70Z2MuNGiHGfBIrakH/+t/pHhUmiLoZ0Q6myxCSJamNkIlzUa= 0i +HUkwAWuPRBFTPeBVBbip8o2E0yVqMuEHmItWRkDqefFCYDWmjcYiv0HKJyFfE9PMma/KeRu3UE= ad +XfeX0FmHG5XDYQf+f7CiFBJ7dl9ThLlHxRpRE/jbEWUhqUetNSJMPftrxkL+T4B5T7A1FZ29Ux= SR +z5M0LtoIBxUL2ssXhfkPBBQ2iTX6UYyqDJIWIl2coEwvJn6ApdozfHiRQW+XBx2c7s0ggUijIH= E9 +IkJcUBQKP22OiDQMpSq2mO5w2pnHV02RJcf4BPpyUG/imi9ev2OD513xMlvj+uInlGzJUa4FES= Lt +bqmqnmeq4+vRiHfWtCIMRji/NzF9rmvHqLKn9/tMX8BXNShIcng0OwxeXAbnOrXuSnrlPQ+zXy= vw +YKRvnb4PKRMsnrSshkBNhkkSLbA8iKD5pkLnvFqDpULRiVixFeg/NuEHp/QThUL9ILo1dx96X7= 7a +7r2s2clAmCDtCmUIzZQYyJYBNXRK0jQJJY806pCia06VhI7dXaVTATi/k+Flg83H8icZWknqTR= EA +zjeCiG5HNF9p9R3WTcMoCsqoB2suEX6pFRi1IrQXYFJOgqmohThFYm/KgxWg/OmQk39WNibrQH= xI +lrVMQe/ccCIIz4PgzrVkwhb+rVZh6gZ38x1GCfAkS3wEfRUD4Y6VmPmFNDi0Nhg8CAtyNCDKIw= Ka +F6UkhDS3pdH+YOCdF6jyb+ued4ue7Hw3oFlFLGi5FtLB5SY4BOZ1aDNegLhgtbJDH9b+yQtRC/= Ch +ZHGEADWAfhChgABrD5otT5sjYWPazu0vLEbN1WHwLbmPN8GhND9exQJLPf7SrFOUv6leBGDen4= UP +4ZJ6+28yfd06NF4eyr8nKNY65shYUT4Utxa961wEJzLYa0ivZKfKPoC2ZEW7eg3gafDMIbf4j4= jj +f/u0fpHXvjgFTFOLMn27iv/greuB7WIZ6RPAOAYib1qC+2i8dkD1nSwlS7J+T0fHgo0eD5Wl0N= pa +xi/Uu20chPvuzdZ+M8mv9hhCs0L4jUxK4ANsEnpGmwr/Uhnyn4VG/qBduDMF1tPZKbdU4AJqly= O3 +QyApiHgDQNfIrQVfXvwP8CWEIIAggCCAIIBgIv31Q+k/h12Ew7bmUCRhe5IkSZLoMqWskbZNKV= XE +liZkEa0qAF0XCx9TC0gLRwsGxWVDKKlxf923GY9wqW1QlN5v8RT4x7FaMR8yRBKMyycTacsIYc= iw +dIwpXFs6VR7liIrboaW1gm0hYGcs1FVjbyLa6kYfooRxacHuDy4n7h9ig9Vg8yM8Wxo3SlaDVW= UU +4n/EVg1MqY1AubeF5YBCbvXwoXjqYOcLQof5QdLI4hbX0MmgGOr0ty3h+Jpt57uOr1jaxX4qU5= KO +ORHFQ5Nl7B8TY2nMxWDhcSK1zYiuee1cZPf6GPSjfe1L2kd0BKQ1k200osCU+ZCo02yVEfp9My= L8 +fpnZ2Fy47Yz+ZhEWxx5B3fE/UmBLr/BMX6U8d8T2X2CWmMYVoOxPDyQnTpO52IyRrFLeAb3mJ2= fr +9zGW1qWtumMa15sRn861JwYs8vNjEHkHNaxc7NjriI5JRz3aHsjDAUGa3VTtiUaT2gvsMU6GyF= eN ++L2TXOI3YWbjMiQiBVhB3AUYIRxrL8QmGMizADPZnhZU9sKlaWnGAdTS5Wy3ND+JJjw/PsLx4X= 5P +RS4s61TEXrhF6e+Zt4RlUhKReBR9XSHH6A52XUThfUyPmL5wWBv9bQow3KYaLLwBYnGZUjvEoL= QP +eV2p/Skge5MJEXKgYVvM64IU9t+dfu3dYZbyiyKNecmusRkkur9jUAzyWAGJ6YTC8xMrx94nlY= x9 +pH2w7yZo/OMIWq7PtJOY/4oWm0lae/rLyqRu7ClM06hRQHBCNnA8GpbYfNBUwO717MQhlpPcGs= 8/ +cdcDQXHa6atpmOvjPy+czRNylNNTDBKrVk1qm0O5pNqEDm//6WOr1uQMIic4/YOEyHUJksgJqI= r9 +BQsK7OritH+tI6Io/hkUKHhNQ7BqhWfF0YLKB0ZzffdgxX4QgWrss0WhzYaHhOMxopvrTzPG0p= WP +KeQq5AM7K1R1B4KHzVoCA/vHNmM/gXr7eOx9SmrcuOzbDOKU1y587tgJ5QP2PyXU7yKWBnvYw5= 7k +cJHBwB46wPB/UEXYv4Uq/icE0fWRSI3NGm5g8YcmxdIHj1Htg+zjjF/l3I2fBrMAv3V2AP4WI1= QJ +BjuxZggxbZCBiS15Q3LjQhXsKkbtXQOV9r+cGJ2sU1tygw+x/dhDsBZtzhUQFNRK/4YIMZ2LEV= Bc +cobqdh2+zTsQqNqTGuX07ElbcewdwAKKF7A0kZGBOrDEtAbhU77ZnFxfM6w2OjWZyE0byVXjco= xO +5mzI3qsEgeIgCIo0Lf4d/wnQnvTCy9DJGw7ud+wV3HPSd4sd/5NNqO7bhqLuDEowbuxpkAF3tY= jr +iHxHI2Wetv4TdyeYNhsi+bVnrEzpCyoI9m8GttQm6czh8b4fezks4b8gW0VOS4Ds5tQK7K8Vbm= ym +fKsTr3Vgqb0aTuQmKNsG6PSEkC49Weq0X8sUKPjMNTrxm4Eh5ROzxebvHVnc1ayu3C8fe5qJLv= uW +YBKq5NTCMS5gkEuDu5GMaXIdOgPb1I5AcV1KiUDHpEvOGEuT4TkSdgtxO7TEWI6lde4p0UUSmk= A0 +sTVi4nrwIXdkk2LpBaaQu/JJwfKFgQB7xqirnizKVTdALhlVkm7VFVviskczkyj9XXIWYFlFIM= De +cyZyd5FLRtXwgZ1ygPyOPUaoK3HL51MuEaVWvYJujdB6iRLSK1qvx7alDpLy5Aa6VR8arwab2l= gU +xyTFHVuvxanBhlR01KOG3DaSAB1LmNlS0bFUqehoqlR0LGEqOnKZio4MlIqRqHZ/RyJXbFtqi1= am +1FZNmtTm+kPxHylXnV8sFeVUUFzkqIsmWbkSJ9jhwL7QdUZdbtWqyYVl1eKytJjXU1fiIvY4tQ= PN +RnwqYK+1TGwuYGNgp2EO+yuo8/SWMY35N4NOjz1dxIPqaD6H9Cq9xXZZtcpAvfmWgPyetqjfMa= Li +5lsKZn/rmYk8PeDoSrTT/geEufkCWqd9i0ty4qmFcEGlNueEue0IEvYnsIe9g0dBUfp8fEEM0f= mG +VOjjDwoIdec0pjePDM1r13QFmSccbh8fPkb8e3IHWafS0thzZbQTxzUCitsUMv4nmtS4KZYamx= Ey +MLEnH9vSlYMp8oIF9jLr0DBRyL0puEqvORcW3zloK577hOrWGG5svoTGmK5VOhiO0djv2CMdjD= VW +eISZkKqhIo1qFl2stXscZmFncIUnab8vFu2nGHzITcMSmT+w6FbdogrsTyMlNhMibUyTJ0n7Yf= iQ +yLxIQYDdVlC0OefZWHoO0l2NvRxHZOmrrqS2KjtP3xpdXQJ7K2mrOzxsXOpOEKSwb1jF9sdgF5= a+ +aNibP5r82mxuxf6HyaDaK+enXFdbF7hgdSK/LOkkvo/DiZ9jdSI/BUJRYjPJW9yB10Qyu7GXkU= B+ +Z2OJTv6UoI/XPDA3fy5UlsbFPKVXTRJdQhypKMYFsVGS5lVMnJgkQc2CvR++dg9HCCFJFadFjr= jI +rV8Kjg+hp9PrEMb8qpieviIyhbxwY3Sy7oWyP+MKMxp7kUuKPfUB++HmvzZGm5fNiXXa3xwc1O= 4Y +yVV/MUMnawrs6dvxc/WBowUVTmaWchFqUvADmpZ+trbkLmwsY8ee7vD97iCU2Iw72G20ps9SPr= GE +Lc1AhcQvZMzCTyXpJD7dDSd+B5Ih/LAnjlQSXIXbY/7URsnoC0qk2beF7PUJoIz9lgPJiRfCz9= Vu +66u25gfXgsW/Agp2mVljMzuC/Y6LrSJXZZrTT0yGlCMgGOTRG8QkKn1QmE/BEpdGavhAIpZkE4= 3E +R5HBxI/jLuFnGhnChBtBoOE+YFL+eDe5d0q0agkGheVVI8CuDVKwpycJyxXdwa54Y6tObZcTN5= 0t +LbGELX2eH0l/RLAHgeVJl7ya1J4YmFK7ErZe4SOiY5FsCVp8ZCl3KAquY8y0En/ZjTPG0tijzB= Kq +fUN1EuyNk8vYEbcP9m2RFps5n8XYcwuJzF8uIRQHs+h6tzYpfQwVqyWwd7BAUBx7oE/jtcUwY3= 5L +aXS1JWwouAaGvv7nFtr8eZw+3mB+YAdB8GLAqDgynzPip8xNdGDPAQMhFYlCRzbag/KG6m4GGa= SQ ++zL7tPRG3K8de7nsp3z+xG81G5vBkG3pjwAE+5jUaKMVIMakbjUDqfDwS40dJZCrNkgwbUaI/m= vL +0E7u2JlaNd5Zfl+oNBLsYU+kA29+xX0+3j0g8U9YZez/DrePrxxITlyyqLEZezUDZG9O7ms/9i= CE +lWdculUTSInM23aqces+ps3Yk6xcqV2RkEQuMZBEHlLA1x4PF3USqrixgsNSGmDP9FH3RSN+dy= sY +1a7MbOTGnqatoLg5qqtI5yD3RIPCMgaBALsj8yF4xMfG7TFom0vHh+LoWK5ai1yiJlYiT3AIQl= 3W +l55KHbSDVeNGQWWji9Yr01jCfnzEzq9ciWcRddGleXMY+ohjRimXREhY3qribD8Ex96EEhshss= ak +Z2yJlF8gGNUmCSIHTiALoXiYOVQI3Nl6W4xI4skyIlEQE5ZIoihuOGcixx5kt9h8CeF+nzhWIv= +z +i8hpNdW4R6wO7J/WYu/yEeKXmR2A3+nxiZ/jAxMf9iQiKfxamso64Fx7LCC9/qEcsQ=3D=3D + + + /+BMrbqyOO1/oKixGWETWbr6Ucg8p4T7PXRQRvBDiaTwy4ik8HudQuL3wh38fTd1zBUoZJjgk= Nld +eDsKjlOQ02M+f+Ksgdpmjc2V2jrKjv2XB+bmWRLp9T2GTGSUYC/FiFQ0CrIjG9jLvDqy8SoPCo= +X +a9BSfLdGxrNQmELngw1b6cdPr/DVZPJPE50ZfQmV9t81zDYfCkCwjz03fzA8kxQ167xRYbkTNO= oe +V4LBFk+W2dpJBA77Cdtm7wKsb/5iQKi7oprezGpTtbFnYxWceFozffwGkWb0CMFJ2wX+Eo7q/5= Ji +QmkcSHC4ReJ2aGlO3k7bvgSpVeM0zrXxCGrpQonwOwbkenPr8KpdI0jYTziMoU77BD0Do9VcLz= Y4 +/Gtkm71vr1LmbyBC3TdLjc2fyOH/+zGws7aPusHCTGTpIzY4PYeUvf4M9FOOvZSkaWkaqLT/ej= J0 +cvj5r80hQafHagGbTZyUExSrE6+YTOq+uAwp50Awbd6tXKm9rrzMJz4B2D/bGkL8jv3Y+zKo1N= 70 +FUvjBm//jKyktsvpGX3L/NfGX2z/AXuMVK7EFZhScfOWA0nKQx/fvAYWQvFDqEL7EkuobhjF9O= b0 +E5K7bSEojj3s0TA5F7lBCs61vxTaZtAgT/rsRso8Jr/vXxOV1MYFCf8aVNVhzwMJpRd0fydTLO= zv +cpIT/05qm90KSbWxl1kpOF51tGBHbFYiR89PzbzIfK3xtXROR8o89iqiM6M1CBLuO0yNzQaC5/= 21 +BMLVHZij9GNLWchGzimD0Q4ng8TJxP5eMT+wJzSpVVs2W90b5JKIyKQ+YI1J/x9XyDvIJeOqP7= A9 +gMiNvYcmtUoUtVduUSEUXysPQzeMi9oLksJe9iNz9qhwzUXp77aSio4dpaKjoiQ2wJVeLxWwb3= Jn +I0gdpCi+ilxYTvUHdn54U/44Y+OGPETxQGKPEBKsOjOpqPsTQ3Q+9nAHI9zV1fXmDSzn2gTQo/= 0W +lcr+S1tBccQh4zJ0Vx+QCHIXRlm1LRxjfkN52v+gQ7WzM5PjC7iOahMYNr7sC4K0ardlbXTEdJ= J7 +gtktPTmQnPhkg7a5rEFon7PePj58Hcg9hmLuQLNddzb7hAK1zaMY6vQsP19bsrqk3LBDXx97BT= Ah +87JYuyAgeH1bWiG34dKq+9UwWPjKq7Z5c+JcW20hYHdYdKs2pCDXi4mP2xmMHbZQV/3iRHujBp= +W +xp7Fphp3zfVp6VXT6vVF12bsCuwlXNnC1ZsCh/2bk5delxvh/pmwNysYGgXvNHbsx17CQ3o/Tk= 8x +7yOFNhvKBMfbdJbf014BuyUnOXFDjQD2nIlizwbbjH0SUVfdgRHAbru5ucKNzaxjdeIWiFdt1g= OK +HHvhJ8VWLXIDxxsiILtThldtwyOFrRDcmxPuA/ZDnwIMD0EQTOwPuccXA752QQoE+7CShs2Ikg= Ds +2NOkCNpHFSpL4zohctMWqA57B2xYxFa90xWoNmHXcv3BQmVpi4a9ubJypTa7YpBvfYGCY/qb8q= 06 +ybZERxWxwh0RUb309vE7ncq/JeQp/a2AULetZmOziwIvm0EJyT3CFtpHYAic8XP7T3ycZAgVBC= JF +p6CyWcrEvGyKLXHZ5j4NfcKAgF2y0qi7xGFGoy8BLKeHD+zbZUptCiY27obINwis2ifGkNiRxc= qA +gH1ioElt/QhrFNvr90XtlWms+Cio7AmJjuVhQmbT2dIHjeYj6eLj/EIozt/die+NCHbs9XckLm= Cl +KlPBqHYuIBhsy4EptSMfHWtkSCC/W1yJlKu8KZHyEIpnmA5tZ7ulHQoPK9k1Jp3iy1VzxCrlFU= QH +O0mM5d5XhfZDCEL7dTsXmzuU1PXYW1fS+3ETGobPDCQnPgOVYl4VG1vRq/QKCej0GRajkxMuFN= gx +zn08DrK+9uQkV00ewtfe6WfyGIwdewSRkvYJbhXap31UyN8Kps0grnltnCl7fZqBTd0JQ/jaBd= 2B +sWcIzwO3ktEUU2zVGZJg8VsByn5LetbYXLGNTlyDJli89VRQPPayH/vZiX/kiP+TGNM5kSnkOh= TT +5q+EInfGLL5DXEVxmgqKnC2wvTlTQoE9laxEjr3I5qPu3C218DoDJuWy2wIEwc3By+HU0hjJSu= QP +RYvNBxLu90kCJ/Y3+LR07U9injVBdmNEqVoh9LT8wc1Ui8AMNqrfYQSH5SJ7gRQGoQy/x/UjVo= R9 +7H0KPtrXrUwhTxGoN7MVWGpvUl/ntxEWhrOeUEsbEJnIyEA5cIHAGb8D70F8sC4bP+z1/hPfRf= Mg +PwYeb6B1fZ1eezA3/5Ec/i8llP2u1oWlUbPGZtzx7KfRWq53a7QTH9lNX+HuAGnnpZErmWCMEu= Ed +ccz4Eo23MBMnoyekajBknYnrxQ0ExTP+FPMqyZ7eZiCJXIapsRnUtCieWIVQPFRXn5Z+8yr8ci= 1G ++JVmB+CHEaTwe8/d+I2MWfgpYCpKqHVEjm0Hlg7+B+zPQtnrTzYfdWPvMgE7+StV7B9HffMcXO= nd +awR7rtMQucyCDSJjPyjwuH49SKxa3I1gd6kzmqUEIr/1kBOOUYu9nSZsacxnXrbZ8IbLnvjaK3= Mu +EMe7O/Fzk7C8VirYKxUSp6FwFsaT3AcmAtTSCtFu6d2KPz5iM0Qorr1y/2Qo1FxCv1cmkAovzV= QH +OpqsA5YWv8O8bAjFXfVuzd5PODiofbdSC0YbLWvMWFosDRwvCq0y9n++aX6OaGRxnI4lctrsIn= Lc +w2DhJZEWm0cLRrUPmvW1RY6nZ1JjvxiobR5tm7HLOvjaMYPH3jO2tH8sfy1NySr2sPfhFEuHCj= rt +JzQq7c/cSczvRGibJzNbatcOs432BwzVHp2+zh/1zE6jA3tmElL3W4L9vgsZWDrGZQo5xlJjsw= bi +Vfvgh9QdOrCwuKKQURS/3Uj+VwLbm9lRC/YJ41VtVv06H3ttq7Qtu1Enhp7OI+N60IzE/6fAiY= 0J +FdiP0ag3GzKo1C4YUpY+se1wf0Gk94MOGUgLNHE9hjlKTzqlsI+9iw60t4vxr4+z1NgcPghQnF= Og +Grvix34nSwLRhCvG1M31LQeW2isJ+vjPfcB+wTGbfRyl0ObPlrP0z8GBpb/k6eNJowb5r8D1Zg= 8M +9zsHsoH9GQHJP6cFU87xwNTdGkjk9rA5VwAJofiugtNsDyq2f2Ib4b571TZ3ROtr43CJ4q9wtx= CT +EzE78XSlUTeGdVLuNRRy43To69N2NjZ/GxaGr+JmN2X2UXcBGS5g34U1LpvgvwpXVZa91wnsd2= 8J +1e2KrWwGCQeQd1N887qNJFSZTDiq/xIkHgtKI/FYSKbBYXmwZygE9tTisnQXOfYKWAOI3BKSjo= XK +wEk3zdi4FyCXjAShjrazmKnHqCH3iRsM1stg1WZkoWlprzw5WA22QdPktqhOnDEDgb00ECtcW1= Qn +vjBIwZ5Ng4rRkshgYMeeF7lC3rCQhZmrfgq2mOeUHJlnDWlGuxAR7KstlH8MqsD+2KLG5oynV/= iv +yMTJSLggvGpLTJSW/kCmNxeygePb9XX607y0pf1zizG/+qrYw5Hd0h6wJPLRgMDiO4Lk9duOen= MH +PF/bpVVoPzJTnfjO8VV4h0DzhQ7zczNz8zqRbtXYOykUdVdMctXe19i8wwyOh8wYIjdwekZ72E= us +EwjY24QpcnWWUO3dLfb6OnYS82vb6OTD9iLX7CYKng8gQud4Pyb/baa89mHT6OSMf5S+RRptdK= 2g +VPoyVFn6RGmZP3aqOhUUuS4B+T0huX087kOAfff5E8fYbGw+4ApSfqPRThx7GI1J+ai4XCAoro= mk +pW9VGdfnTtnrXxIQsFtyI9xzBzPP8SByv/ZC09Ig1sr8rxjbeydyvdktPFwJkWfQj/Zrj0pqY5= Fl +7Of61RKyf1OgYD9YOop7Voz5MyQG+Vzn4PoDmY3NoWiQ+Y/geb+C5mV+1MAKMo89z6q4+R3bkr= uF +u6zaRT/at1BabKa5JClvUZ2Ui04q/wk8MX8hNFU7c0st/IpAvRmTwKj2e4PQ/k4SAvsuVMFusK= 2R +EXsrcrVqAlhLeWKxgf3Zqeb6DIKEuw5TYzPC5bCvOzn8uwx82QWtQiy9+zidvoBqiLyAJ+ZHzR= hL +0yyhurFnWX3YrK52S2tCGddj7+LB/Y7xoH6fbNQ2a8jXx1s0mP9Wggp5RjITOUpra2eITkqvCy= jN +jt0ipklD7g/LYT8UE/xjz2ZLY3piqbEZDFUyGhwPIK+5FHgIMQ2OYOpWETOWvun2d8dCZWn1Ld= vM +XlgbzSktYtrz/tfeIUzVxhiobR5LA8fPIJndiBWzH4eglsaI3FrBvHlOB2P+tfIh+FvrqDaNDa= n7 +mwyqjT1w48Te1VbsqShIhRO45s234kXmC5+FfYtXWRp7Gn+Ox4gaBR8fZYUjYHkVfpUIAXxFje= Ce +B4cDe3pBgZ0Ri1A+ELnR2aPCLWftlVnHWK66k+7hkdGWfiP3YwX6HbXExs0gJ72jOFfBla6QTn= I7 +Nie519rJOLFUX0RRN0KVyOenJZKI0O/grqPaMNNd9d8qS6ca9WbC+ar27OQo/W3GXa1o3/d/X2= bj +Ejf/VjCqTeD8lOfUf+LYq21cb8am9bVxpXHlkNUl5aQnaX900rwG1fagKvaPK+v6AwW56t3H9d= pO +DvveJlHtG1+xNEGBpmG7kd/rMgC/VZeNH8qmjl+nUpD4CLPUhxYxPbpBaJ8A+TL6dmAjdwxEqL= ty +1ti8W3BkXnOIwP5Mo2NpkoEA+2NH9ypIOQZSQfHKJ1Q3bVFjs9ekWLr9CvgnyCXVBrEnSlQZOO= mH +D3I9SFXcvE4h4//boa9fA29sJj83pnW4kMkKH32nsKU9rNDpLR32ZlelSx8RheSmbCipLaIGhs= eE +NwPmxEc5d+OnWjj5RXA4UWVjUfxUtF45I4GA3e/ypH+SJgX5aEhGbme0JyVSXmbsdYKCyp68u6= XR +1UfdDY3sxL9FheULoyAqxgXjxBIM9uYO/JH0D0e1I2bZyKnLlNr+/ah74X7EXg+YlFd0LNV/dK= ve +hFgbnT2k98sYILtT0YfcfsywGYvu76TNEtMaw6mlCxgR2Fdfss0dksHxtpFl7LQcaG8cyzXYjB= 1C +8Ik+kN0IDEm1DZav4K2K8HuFAXvzpkWl9kFHl17TKnB8pa9ETnB4fArVxhiQ3R6Qauw6wu71sX= fr +HNzcyVP6zbfKPEkDb35cSyXXE1BryrUK0fmegUDxAjmSeRk7ifndB22z4qzNPr8YVo5IKWTe1b= xi +HscMnQyyGVj6qkKBOxMltUGar+A6VKqGGNWZidxqX534TWRIedsxqn0hmTKPmcB+11Q6imOPq3= rE +/f3TLMY+Y+A02zJquV6yIZidnBsZHE+whpOeOCAqXOdCMhpzgYAdJ0usekdC27wmMKpXp8C/fz= Xq +7hgyIpZllO5euRTuVAPxnVewY9Y7lSvxG6pbZ4mUp7aEaktsqhN3hLoSv2RaFI+YNA=3D=3D + + + 6jZPm7rNsPbKmYrqgPxOMTCR+7EmSClPE/iyGxEXuVMDF5ZVBwTs+U2t+qRsdTdID/ZS5alMR= UwT +uXGj4dA5TAOxEkmoto3k2TSoGh1ftmSz1X2GF8QHdsiGQkJ8jKX/9yL3mqtNDpXCImN+7HVAH+= 3j +PimWviAQKM6pFdiOBWT3LdYROcbwyGgRe9jDlToK/qIi7Bcwod/Bw+3jPy218DWZjc2eFHPz2J= tA +OthJAo39B4REd7D7V7fqUQxn8xED5Hfd4cZmtzB6fQfFXTVBiaI46VBiUqvWpRByf6KRxSGaMK= Nv +vsZmiim1apiNx3THhGE/yREVBrDCw1Td0rnoOXCvaDpwo5px+YabKeGfortaRLCnN4SKy26/js= zT +TJSMxp4Om7A3W740o3MdXXrsGV4G4IgPN6+jkfyHK5Glawo67au3NKZtG0pqqwSJTmZ16d4ad2= Qe +ewlW7jz9DoETmwOeCj5bQ+q+zdi9d6DS/hYH2Mk40MT1OHK16raQ4HiCXbYZVPtVGFFvvj06uW= +W +FEuLBfR3xBv6vYDWnl7SESjuMRp1H6g+bGbbSkuHwEK4Y4nc46osHaGK7W8PNP47LoT2a5PRw2= Zy +o9I+Ljn8r28Jy+JudAqJnzlqxW+xiYDfahMBP1ShGj/DywBHQ9mPvZBgxz/mwMVmhUKDvKzTEH= kE +s1v6ADVY+PFVOf2DAFIzI9jrZNnr84UF9nGkRCfX3IzrM6ab6yeHDnZDq7Q/9l4Ug/zM424kFX= Vv +UnzzhQK0zSJXwb6LjNhvgX0+fm0nMY+RfBUeobU1/57kxsVqMT8T2d7cwWVKv8Nw2K+xUP5vZS= W1 +MeGk7p3tgt8KioOq2P4fabG5Q7KMPd1RTo+9mgG1N40bLPxbvk5vFvQa9giPF9N47cRZ6PyXxf= Tm +EYHM0i0PjPllbivmDShmvw2TWnWOYNHkPuQuOGYsfSMlOtmTVbBnWNL7Ly046TEMJbUpLpe6Yb= FF +z5DoqCnlSU+kBIOtaUmqXWigULv0dRkSvno3qo9SNDKe8PgaI/Z/qozra5EWm7EnWkXGbjN37L= cx +CjC8Yruw9LdD+VfRRl1WmT4ee6lhdeIXTgjFLaFq4SUbtc1uLefabQdj/u8VWTp7OLV0wbZqTg= WH +5RYywRiiVy1RsGfi0jGiLAaH5cLQZb+i6NtBzDzmMHScOW4kr8gfG1Nqm7HIga8OksjNSIqlGw= uX +pTcaJzaFUQF76iA1A4H9nwVYtkwgYH94KmDH3oMSkvtB+ogSEjfCx63BZggBxuCfTznF5Aq5o4= QD +uwaC+D0BYmAPmy3aVG1ECRp9CM7AntRSwjIPz5buLhbsGhEKyyFEJAuhuOTApG4IaaTak12A5Q= 4s +1H4SIiVdvf/NIbvFQ8juTA2V+czitD8sr1aNOGGOF+0d0mwCZLVqbHZXX96X69WQp5R9bG/GXm= iH +Aztr4lwbe4bQT7n6sS1Nrir+HRaCVYOrnKXr2EnMYyCwN7sGmOHBfJF5XKoW85/ZjP22MREzOV= 5n +ak9PUEGwD9YK7B/tzM2jNFQNeza8cIw5g+KyOQuYZuNI3OYQ08FOmC1YvAJB/Y5+KKnNwbCll4= 2u +jsypRG4IMSmveXfVqJkad+GlthlUfdWeubjUlnyrlGMQpJR/thV7lId58znE6sR1+yLzGwoNw3= ed +g+tvZ43NHFQI7BOHjoWy/xBWChzEmH9hTm6+k85mn+UU4G5w+DaDmvzamJye/ib6kNvWwal7tz= QM +XGYH4mttN/IjbTfykxnCw4f6OONnM7G32L3+K1u4Gh8cWDqEBFL9zXsuItgvTCrqJjnSMCZOyk= 8m +TkgH1mYrk4kTRhehtGktIDT28ohSUYLOOeku7jy9rq8KfoEYLPztk+jkjP5QnKBCtXT6ni1tc+= zG +ryRnkvBrz934MTAL8DNFCCDHHsI9J31t298xJXcyguCcdMMtdHpv2+GuOgwWXtMqlR4tgNRGlF= rG +VDhIyxrsUuyRENQulZE6pKMWnZa3Yc3MFfLwY8DuvSJMkYeGlKWjFEpq67Jv8zsCVVtGK3C8bi= Qa +u8kRqh17oISFhGV+ZxtttKgDb/6yWBXcUGpKBf5x+8I/x6M0m0Rr9cakp6v2Q3B0xlDtRixy4J= zL +h+IPswDLbaVTWaUcFcVW3XUOclsoJSyrlwrYIS1w0iefrW4OcsnoSabUpiRWIvYOuPUqKHzBwN= om +zJw9KvzDwc5Y7URuU2FIIbl15pLdi7IowHJFf2AnLQSrnhxcTtzMXOJXttRmUavIcd/3+6phb/= 5M +8LVxN1bKK4dXtXXjiP83R/bK7yCJCPZB6/v+2ofS0gZZgf2znY3NBArOtUVK7f2HGOrjycQGBJ= 1e +kziR2xucGZ3bqd/VUkHm01aCe/Pbalz26LUyP8ZwUjf5guweWbb0hFXFv3rB/a4zMIU8S1wYXi= HN +C/8F0vraiIfud+ytngLcK5Eamzkr0dhdhgX22xFtow9jwaPaogZ9/JhdpV9XpNdXbRLV9pHUuG= 8y +G5s5D8XNI0i01S7k8H9JjTbaIBo43j2t3r82ZrM/se18v8wSqu1BM1pBEQCwgAUs0AAEIAABBz= jA +ARawgAUAAAAAAAAAKEABCjjAAQ5QgAIUMIEJTAAAE5jABCAAAQgsYAELSEACElCBClRgAxnIQA= Yi +EIEISEACEnCAAxzAAAYwAAMYwMAGLnCBC0hAAhJ4wAMe0IAGNEADGtDABixgAQtEIAIR2AAFKE= CB +ClSgAhsIAEbkdZPB+4HTQGeQ0mAu1kQfWBxY7AP7QD/Q0Af0S3RAH3A4Dui9D5QOOMreHbtzrR= sM +hUMvDuyGWZoM7nA4TIaim4wDfWEyeulYcIU+UJadsXB0rtAHSF4rOjBRX5YKJgBWmj1VdGAfEE= Pv +tP0D27t5rH9AMxqskqFaqLQ2V4nNVY4EbywWicUq1UisWCqVubXBDokOiOEBhrcSHdAfA51BOg= CD +V0cAlufAgmO+3t3R2ozWilGWidWKOxKqFmuRcHSDMuEwV6ldrnT4dQRgefIBXgBcTdchAGtFw7= Bm +BuSB2or2YbFwlnxAe+eBlkxzwMFYlHo3dG+YpcJ0cE3vDYdi89KbHTAd3GFyRmPrxYGFXphcK3= Tn +XgFEB/QBh6lLvjAdDodj61KhzXL33lj0hqPBMLvmutwLU3decodjK/SBzlhsc/duLvaCl1zRkm= kO +dEa5y4bpME1GQ8E51zg2X5h6a0bDbCjKRcObHXCUDd0ZDIdpOhqKxu5lQyt4XzC0uWCYey8cvO= yc +odAHzL77omFqhmNrx8Kh0AcculyYjb5gmCZDO7Zm6G4uFPqAPsAbjoVZ9r0burFY7Nw/sPAGID= qg +vX9AeyfsPXS4f9IHxH06cB5IMR8NK8q4n0/Yq/wD2qNpDoj7QOilNAf0AV0e0AfKkh9o8H3AYe= JY +BTDQrGgVjL0VrXLa20MNkEu0YWGEPRpbotjDHmaZJhJ72Msce4kRezpnUpPkiL2txWyACHmFKI= rY +GxEZezgTe96UW+VKnPVjKMoFZKJjbkt0zKdN3bg00ZbomFCYxta0N5piI7cig0FDG6aQO4OiaX= Lf +UJ2+lOilVJjUrbg5DN1fSnTUINGEF4RCl5oXF2VCUWadA10CzKPQlQn2XJxMnKzsJFQJa5vSKf= kK +3hHRMLz9vFyfcg6u1xEMHH9TjF6fLMsKH08HAgd2FARi6IyznDVAbMViERtjSiEAoSycRalEx4= WL +BfsulegYhgjQUZdKdNQbEeyKkkl0kBXckXHGqDwwxNI+MnEUH41GqtOoREfG7FHhi1AtV5uMPV= Si +Yy20QyU6iqVUNxFgjCGWi6alcj/2EC6FbPImPCU6JhYJkRtwp4seC/3DUe3NKdGxgZGoduaU6L= gj +CVWNJU/ToNqcEh0VoyvFKdGxv5LLbkt07JbExRsuW9GuFi51Y49sU+FHRbQlOiJuE3VvF8WWMy= zT +RO5EZtSQO2Ogc5BbzJToeHodyK0v2XKIlAezJMHVQSFDnWisKUx9jO4fq1z2K0SXPWFFaRnYq+= xW +hXRHwQz0IgNVMvoWK7ke5EAyOmIbpfzDpRY+hyXsP12SlKsSBNhHbK7EHem3OvFQBPv9xCU2F4= wH +kJfkDKq9iq/Tbzj/xMECiGZE2+gNKcLiGQjYySIW6uPRxHcZUu5uFPxDaBAWC2eprWifh0ceYC= wa +HmqAD4LYK9nIsPJxYVnNhEptXvZllkh52UgZb/gAFzktUBGSA5+IUrBc7rCgulwhx56j5CE7Yi= 8R +C52+okknTmjsXl/nWRW85eDAjkMxbSZQEBVOwehYmrCQjV96U8dPcciJz1ydyHBFWHkm1IIde4= cI +7s0EhIPTwxoVdfuZ6sS1znN8yl0d9g4dmlg5cKkbpxJOh1VZOu6VL/s2WYw9PbiwNC7UUo47CX= SL +cvb+nBlZuq2TRT4xkHC/WdA2Jwz7tSMfRuQbjYL/Q271ptQODxauvvQ35bNWYtUsyPTmBILy2m= pL +KHf8h4TDzRcMjk9q1aENbG+cqthPOWCodm41WPh1ZmPzZ9SCnT0hOp8QqmQ0grYrjZvNi6tFTC= Ms +JJFjb7YZbTTGgQr5xWZjM0bygf2m85Q+jIT2HmFvpGn872Ij2BMzGNjB7Xl/B1Shfdo3PWzOrS= Fy +F0S0FVehbNljz3YpKx8KubFXObAt3Tg/LX0xcGF59bSRjyvkDN2J50wtPSm5ZHwhOLE/YpbyRU= ol +ha11i2KsDaejuKKUQkcX8VL36Al1eLb0oWCzagsC8VmJPOkYTQnLGQkC7KZkJfJzuyztKHlYfs= RG +UEKPKleqBNNV/VSfGa9of6hichCSNGS8Tk9AllQ79HBRXDYbbXTtgKHatIfBwmMvJ3K9ORejnT= j4 +shQi9l6uSz9SSNoPzxu5z1Nm8OBS24LKk37LyU6cciCdOJhoQREE7WDVE5HbqJ2LjQQB9o7AiP= wf +SCKH7NPQMwY6lv4zCsZFUbel0qL4VsGVnhycGe0Rr8glBhjY/1h7Ze7aGY29iy2RcrOMRBKqHT= 5K +k0zkFNEqtKGNBKil0VeT2mdvTHoFgfjdICaikQRpAoGqEbg1Ahcd+YeciZNCzqDNC04xoeRUBm= 0+ +TlvyGDkYpxME+xmbKbXJkIS77nW9WQPBqPYtlLD/sfmoG5Q7qP1w+BRmkvC7vCn55WSS8Hu0UO= I3 +ymFGMm/7ZhuNvRAIcvpLiqD9As2QcsqixuZvhGk2DQQj93fbGU3ASRMR7FNIO6MnYYbNrE9LLz= Mg +XC35UFr6U5X2LzxG7IdV0BqOtKRYOv14aq5USUkUkSvkIBkM7GkG9zvD/YjtGtKWjpjOlj5FIo= pP +SC4ss5kW7BKfgSDA/uB0FDcVLktHSi4ZOSpIhUdWDJGNjK2XwqRuwsb1ia36cLJkk3EAcdvnnZ= BE +7m0XDkm1UYva0joppKN4mCsREpYTf5UQefYHNnWPnp8iGGxKwoucBnJpIBd7ng0nPg=3D=3D + + + kmpnErMTN1g6Cl4YTWJ+9zFtznRTtQ9UUOQz0ZnRJUXp/SVGBnvYS9XV+0NVQ+ScDCKj1xG2d= 8H8 +fkfPGptDV8E/9nIUDvv5bL2f5MAebgR7xJJatdvgsH8RefarpVLpIxtKautEs83ZQnY+gQCCOb= TE +t5kdgF9uocTvVXjDDxRtsQL/h8+6XlNga01cP6OR/GNU6OuvEJJqN/6MhsUWQlJtsZTwv5GAnQ= wy +xCxdc+BlftYpuf4ypjH/mTZjf9DaGsZ45bYCh6COiiNHIyEQ9IBqKTgEs9kn7Fz2zzhC3TiFtn= kD +W1V7JYDQ/mdhKXih9EXeMWTwaiACP+xBJgjxyxEOiA/FHfzZzBRLbYA+/m90LA1uEBUOUbirzk= jA +lF9EBKum4fBE7lD15apxySNTNyxnxPNjSx6vdtQyQc2H0CBHRUkgf/MaGck/5jITee1WKr3FRM= lo +3aZs86HksN/zZnaHZE3kIgtn8yyB7c2hAtXYdapx5buRaOyoJTVuDnk6/c7F0bVmavhG/Sc+FP= 8J +TSniInfEgsJyZtLB3vCEUPzPEinXIJdMVgwRe1+kSW22lCfdnzGW3u5HbJ/jpBx1fSSL1it/UC= EU +H81Ug82MU6lNScpL0ki1EwqDyLVpIvfWyE58YeIoTeGknCIqD1i1J29s3IwMxBKSO+K6pPyy2h= mt +acF+x3wyFR0/mQpqEIA9JaVWvTOdLY1BhVDcZhJjencqsL/2mt5sGBWqTeqQ3SAIekjp3qGIhu= GY +fLN528EI94kH9Kj2YxNjaVtBQeYLZmhvRM+wsU77eY/t/8BgYK/ZTpqto6gsbTNrbN6RYix9KZ= yv +nRgjsK9Q5Ga21MZeB6QoOAhVyWh3Nax8PTsKfi48bN60VpGHbCT+ZSXXg5EPxXekss0hjgD2XG= kx +dl3IwNLXC5hyVtHufTHFagnsga8k5S2FtuKHG+r0Oo5QN+7h25z1+dppAfTxkgOGan9YlaWHWj= tC +tROsRhaPWNxV58aywi0uw2XrQLnX9ObduHt90d1xQu2rtoEETjrocW8WU93vuFjjsm0I2N6zbL= Dw +tUSQfqikNpRJksQoCIIMMgYpg5BTtQfzEgAAAAgGBERCAcGATmN+FAAETy4WTjpCLCIYFiQUiI= OB +cTAUCAsC4WB4FApFkRxHoSRQMxWZC0DAl4n/BjSVLOF2XWBxqHKoGW8SQ+J0nOLjXZOyijG5KW= 7Q +F3XaGwy93NC9Av+XSHs25cL1uh1tGxW2Bf64a/teAM6Z66MGHPnoM5p3f6e+RI+9yFud4ViyWy= YE +EKcioR31kbDXJPjtrXSVNEfN5KIEDQrV11KSEVGmX5mil5OARtcV/ZIsfm9FgVTWUVk1TixiQq= UZ +fX7pdP1hPRep+hyNCpNYnABu2GmpTJjQDYgBCJIXXBCgqjvKysv0+QFWTOvOijP1Rb+7Liu5uM= 4R +3SjX8iP77CJHVP0C8/xZKOAuIno6qZvnCLO8k4Y2XyyI+cH/sJwS3dj5zdC5yyH9RAKcTJl+nj= LT +Fqaf9ovRz91oP8Kgn87MZeiJWFL2SucplrSUdq8EaSYLiqVWPUdK82Ip8UrFH0toEW1deSXPjK= Xe +EDAFVtgrvWUsafRBVQ7yRTSnWMKmbNIr4aZYGv8P9EpgP5a27tSObB+dfyz1OkktXwmSYqmSyP= vC ++NJ5pTqLJRCIkhfBkWJc2ygG7cDOA1KMCEqAjfJ1qdLSf+zNCvG0F/SNYsChIJ85Rs7K5XajGD= ek +gWPlXyAUhpEDyikjxZB9u8IKGMVwIPLw2eMxZ+61UYwSugR2kUu44YtRjOUOdQ3PIMWgDpiz+2= qR +YmTLZTzPaDaKgZrjpYEUo4czZDeKIcJj00OKIYxLXri5g2O5jGJc6j5a9USLzj/YycAC9I8sCv= Gf +poxiSDRqvEGKsTomJVuxA3OlLYUFlJaR0qcLT41FQQx3hRRjUX9rEZoF4kgx+HQTPc99Bj6DPg= RM +yEEjlkFTcKIFTFudlE/sIR4AEsn6VPQx0UJnfBiZPRUirxhPmRRHQ9KC0EDGQ4aifPeiZRvF0H= 7v +KNyU0li4bA3STVC0jjQU+vsmQs1YWUYx7hqwQKQYNOtL6Jb5Ko1i1H5JRu4cn+Ft9RNrxqI4vE= Yx +iIsUA3b6ojUaxShISDHyGILh5rz5wygGvpr0XFFL7YsEJpiztYOt8lmJFMM3jWIsTkgxpn4CWD= WK +wRxIMZS01KGMYojHaE48AJ+wrm/xXucJQFdPVH/YHtCQjFaj5EIyCCyp/lvIWY8LSDOl9UDzeM= JI +GhQ2SqX16FqwkEE5DymFtZCdlZcAoQ1Ldg/xH2QRKgSYJ+NljFzCp0wSSwAEZKolx5+ThNe0Iq= 42 +9tv2k2JKyBci1jAMKgbBXP6k4ZBAoKwYsqJ4LE75tAxUI7xYvp/Sj6pyxJro3yvJEbPj/GMIft= wt +d7g8L4zUsIjSIqYYqMXCQmVzpytjOXeFuDSMrVOjtUeMJFJO3mBWPemZP0hcGNvHpDtRgpOWaa= iC +F3x4JueE7x62t5bcrSvSwLPHoScmBzJUPWJD+XlqE1KCOHhSf4xy8J29pLy6dnBzjSDGSiePfE= 5N +9EEaPbK6jDk2tbvq7gQ3o5J8piR8Jl7vsg15JrPSp2ochdoO7rWrcRmqwR0FqzW0qjy4h7FzRp= xF +CKKb8LWtKJXMTi6QZEO7JLT4u8O1vX0E1QxkR7LK1HqNvN1cpk69TAQa0tazzQJViRDtIV4jHP= Wx +EBYOKd7YYPvdkQjVpVXuUbSj/5V4kNJJ9GCJBVJilbVZgM9zwVd2/ELdGjgACspB++QEZN33w6= gQ +kaHtCuw7xKnOUf7Pe27dcApNz7yFGsjD/4bK3EA8SkJm3wyu35f+Fe7miazaMpoLhOOvb6ff15= Bs +8OvLfSh+3xv9vkTkDFXMVgUwImxoHhmEYJ3LDGb9rTei/mZI89k2HkoVWXt7c8awdec2Z844+s= 0Z +tG2iyJkzPGZzxiJoI/XMGXrl5gyT5LWUKXPG8VDCuLsEklNJG4XPWtKb8a62oqGLWDQsG+oIZk= Vj +qKVQV1t6kXCJl7EVjZ5h0RD2SL6wFY3TWDToff86358/rWhEa1/hIySFCiXAaORVjIYj1SMpd+= po +mxxONhr9qEZDw2Gj4ViZAVSjISbZaLiIFE7VaJwlGw0SmFu2Mn08F9Vo5CkbDatGx3RUoyE42W= i4 +X+7aAhhhKLT4Fl37FspVQGsFheo5Yo72j2b41sXp/cWJVN+IKiU3todQFUmNVSTnNvO0GuwzKW= q7 +D9Gly6fG0bLOCOzDDSkbeSApj3xzASxRoTi5QOZAEZ4GbDd+Iky8y2gGzK+YSzEqrhnEIqh79C= Aj +yHOEBi6pi6s98XtrBJ0udqeddiazzL/5pF6Hc1j+dLjk79yVc/i3Aa2fDnE7Y9XxKLaac9BOh5= bo +DQI3BNM9qTOcQ4r6C5hyf4UY55y9/C3YWP8hfvnka4XWXzbpwkDAnEME6VBPNrqBzPkdQZO569= Vp +SZCM9TGeixABjoBIgvhQQMXKRLULNiZMtO4apWw3ski6S6VMVwb9oyMLcxjQuZflvCialE4GkD= Jp +wMYSojeaX3djX1Fn3aYrgN7+ugZzW9zLPKLtRThJvchd3ti4BGmovo3tpmwEkJWkSmjfHar6jY= Vu +16ozOHTC/vwei1HOZ1Hd6j19aaYUNwkyF+iHfrb9PwjHXRlxlg0EcT4pKqBPOJZ6JUhJhH7Llx= lN +fgsnvmxDjbtPV92ZSf1hDzq3c7UpI3NPkNNkqs8rDTIBIIp+kcMq2yTIjmHNHxtthK3aSIYjd+= 7k +0i0R10YNU9mlxa828i6SK5sl6oalArEOB7kReDAtcsXo+zJhi+loKZaqOAL3tGW5L6B0+lDqKl= +7 +3dMeB1/wEIB6yGNrp5O9QxdYJQeL0m334I3pcnshRxaWWe8uUJ3yNSO+yF3Yl6QlPMXnxkhlpR= qT +u5OOM9VdFymUEfz8J/QW0SsxJlAHotASoZcvfgeb5JJ/nuPWOCmvkhaLnhO9RuXnQq1hCMDVQJ= 6v +qylMlQOl0Zp99pMbGo3nSAjLV2XR0/uCehfcLSvY+x4IPgOMJUlCKkwCyAL1Qh6/AmfU8sR4gc= w8 +V5Im3/F3oD/LE1enpEZuExwRWmJw4t7Ra5yGcYawdIlJbMK/ZeTBoGU6nQSicqTahw92rY1U6n= cl +yL5DvkGIF26lF3bZjYGXjXe8FlZ6GYKCpq8eSMU3u/Ryw0e2xS+KPLHwoNXwK9MLhGr/Gly8iM= AU +ZnhsI/nu8FKG9NL6aIJJFDITeddAsE+WoSE5iJeVzZ1IL9sZycEUgJ54GSZ60ZyrlzbpZACuTH= DF +mrqM7XhhrV4Y5yA7GNK2G1tlL5LOVbTnUcFUfnQg0HiCYCzUQR7v7AZJbK2MQsSWGS3/lRmggY= ov +O7JdCrUSARpuxAZ5LZilPqzerAOvVz1/bwMzs7TR3D/YAWiUCAZ0Sv7EkYR/JCJgtyTdN7CLV4= sJ +7M+UjMuHrUJbyZj8eLFzRZ7PS3DMAEzzlN0slRYjJEpMI5axLDYOW7HWIcRS5sV6kM6feKBtm5= HA +YDTAvnsHuqRnpZvup0b0zgO5GdT6hxGWJQ9q0ffHyIQangjOEFO0Dda8/GMHom1QLdUYVUudX0= 5G +q1gUbImSnZwMlFHynY3hbpaQByq5wbHbjOaY5DJKoDPrSk4x5pwmMVOU1MawCB5cB6BJ3IYSO2= NY +5O07SC9EQGySKoCRZO2V+Ovk+PNTcyXQkWUjOIF7nikmKdAoqQkMVy9wU15gTJY8D6CHTYGR4V= DW +QtfKxRJaWOEfS6hUkdtfNZZpbI2m/lKW9r1B9D3Xt6zbmquFIqNGcHEeqKMmzh4uib0rwu/kx2= GC +IZcHk2y38WiD5I46h+GRWWLPczqiuIPFjBsDzLzGShI/FbsXb1IBycYIvs+u58nOA5Wo4LW8M9= SQ +ypeBX7hqkixK2jKNngeqUNCmSu3Z7beflT5fNNd2F964J6vcg8F5AMWVvck3SxIHIyAg+8hnzi= L5 +thMb6MbKStTNdg3mGzGwNOjMv0LngBEklhxdNv8PRNe1a6rnv9TU7FPjovhUl2ms3DVWliTkKC= 23 +p2JPXhWrRQlWsAmyzskm0GgOn0rBZ1+pzwBrBC0ly4XPtO7pM4hY77XrNZaRMaB9031cDwpKQG= 7T +ZwabPw7gmXHq1ZzVDG4RTSF8m8jQi6+DieG6yhq++QbhkmPNLecuED0OgCBriFqhIHkI7se0at= U4 +CHXLgFl6KiE4x67mEFyQvNaCmR8kjcyykCSrnpQsasp6GBYpdn1KBjt0mcPmwhxL1gAhYZDuUD= Lu +mKRohjc3RgyLJNs6HAB96EHbIsWWf9uKcB5KBppHivZ7mavWJmznKFxp8/J05hYii5DCdtsCNv= Ml +184tjt0cyIEvEkZSJezyRbf5gmYMN/u8/zu7v6tmzq2JGe4ol9D0yCKSqIsIQThInA=3D=3D + + + ywFD/IKm2TQQbIxqAbwbuOPfATTgmFHvX+FNXyuHvDTAauohfg37+rrNr/gCo43kvMQuF82db= aV4 +ixjF56qhADckHQ/qgFwJREQmev4XbNRckGHZEM3RdwFuSG2MoFhe37tE7NiHDbBsxfD+1MynYx= rN +A+KFavgU55lmBb6lsa5lhRbJcS92807MCt76G6nRjbyFBYGvk8yySyRwe6mqTNNRfP84qDcZmo= +A +6YYW5CYOthFuWB+/6rdmBepLV6vr6Ib7IJDH6aE0Sx2QSLg8bkov1hZD66MOwZztqO9hzD2Ohd= gY +p8A2BvNiXbgUvQAcZsFC9z2Mv7nCFBaQfWhtLYw23mSPvJnF2dAZjMUm483/VxDiIRQ0NN6MFL= mC +lsCFWEM9nOaeHFu2SQuHauHIFmj5MmbfIKG56AlkJO0Ee4MteYaxnFhaUqayezjdMnOndWMpRB= iX +kvllksO5NxD5IVSYi5h0pasSZ/1zARjLk5zkMHWRsItCVbhIsOgirafkULp+TjIR0Bauoi384Z= uz +yTezpdBw1jWevwJE+P7kWYCtVIrgyn7cGivosaTTGs9UVVymNdJmdRNd5SwAKI9yDumGIzfuaM= Pf +ScXBwyntxAYaTCEIOs3hguTYOxODjdbGlXbJDy/Ix5n7cHIMp+NBEMiy2pHh3RAEFEgh0GapHR= WR +Qe/6jfPvJ7cCWhxhBAcnGdQiJqyUsW72HKwCfZyD2QSBfdOOdTCBcz+mh0UTyXNgOoKkMg5DKl= zh +C40rTY/XPZOdrJTCQi3Tzn9pOc4AJ1t/fo9LRwvQx1t0UaWMuCQrqMx8KnxZUgC7UQYEKAl2es= qU +8qffBwPHvnjQdOEZPtG26lyIkFpdy86H2ec/vTlSMHC3zQ72Q44SLZ+EpH346H5Vr+CcugnkzY= Rn +yVMOTGS5/0t0f4jb8zqsCie5HM/ECS+UGgcdo/vXx+2b+Q7YndADIcxSZUCzfFqRtBMCOmJvCJ= yU +g+gIScKBEwbB8wft/QJ1Wk+qFtsx++PQiCxM3sJuEUFIS+me1cPyHPCd32R46V7Zkcgv4cZk4b= Dl +8N/bgJUlrQDnwuEjYrkrTsevopHnwgEpR98tmTckBz5MuJTGJxwgZfHjXRe7lvOs4c+r22HZer= fi +YS+n7ZqZd5Tgu1cOyp9wKqkFnAt7qb+BXljlGwuaISNttxa2h/qwIg21RACdhiiiMu5vkJQ2FG= GB +gb9BL8ggcZ8xYH4XH7FnTgoI/4OoMB7OgPM9VXKH4TUruHB8/kNL+rFXh9W4zVjdlMa0e7kT+m= Ti ++FCnGaKQ/mEvxgh8fijjNEvOfCBVHZWTAfAKooupScwf6hmKcGuKyIarCEuM9/FWWW66BBxJyd= 0+ +OkqaxvM7hNvisGKgMhXWdjvBl4TLAipraPsRJUnANY0XRnkUKWceG/S3CElucodrq6i33xFH8S= bV +ewtBffwygmDEz2Sj9HuZoYcph/93RVbkNF9b2HAf7lrDZKLOpfP92/uMNXxCHcPn8wKcysQQRH= c+ +nL+bzvXX15/RlH2+1evfvXlfSuJCN7I+PpUqUhFw0hZxWHMo6Ze4bPiyljX2PmzQKXrfT3kLHl= 3J +VhDIJzo0MViiYdlFy0ITQVr4kKZZehjFq4zVLhmmQaj45PnbwHEpslHF9/k72+Ns0ZzqJHOIio= 9x +F3GL3JDFR47S1qr4Kg3z0s5FNzQO0C0BLDcPOtMk6FvFdxkmgUYqWFEUCLzVwCdYoZV9HartTC= c8 +627SOLYz7xvr/AIX7DPfbnzRXg2nq4tF2qrTXjoRLVQDeaiok5zpObrR9k9Co1cFuBTBu8gSsA= kS +ZVeZ5ESZP0WDD1+9x+1WufStG1541EWOQBoEfM3HfWv/hX+kcZddFkR4ZZAbx0LveNb8mOWyN8= fl +7cnA3q5ai5maE+1h98HdliHxZ2L0TTYnRS3T+BGSi2zhTxJVQ3VuGywUIEFk1sOFCYPPr9EoX7= LG +rKZZI0RCjPMN9HNuhUNTaJk3EmoPHjF6WBSLPR+j4ktmvQmeWVaxAw/68HLHeWm4836LBonsqS= SX +rW+QCTY/kHhoEnEMvRr7LVz1UxEiFFodxpeiIuifwong4PSx5Op+rXO4vqwwcsDYD8GpeHifXf= rD +VAS+zmTbcKEfR8nhuRApnJCsW5Oq/er4ZBR22IJPTcsl3nH4KhrXfeCKlr4Ib190Xt98wHzwzT= Et +z8BlWFwsvMSgUywA8j8oWXkAgzoTSLlM7pjDDxr/zH/fZYRAcO3Y6GVnsMUt7C7YD4N//xya07= A8 +0EH7QHAZg5IyVgOPJZiajSX8Dxw3e8+Z+isKcudA1MLyHeNrQr90wsLC+RD5koNXVootv5SnpQ= qX +oTGjgVdj0uTD3++OcWMGoNEySycGDDsugHS6a8zkn/c9tYnfYAYfvsBxYQxfPsmCfxul15LjP7= YB +O89Wg2CXBeKmxfppJ3jQRg3/4J9x9/dsrSO1NL1HmTZzQvi6gkvhBcA4O/GWZDg4pjr+8L3+O1= E8 +CYbQH32kAHRF9Al/RCuMWA8CDx1eKVQwf8Z0pPWkYqAfmnyvYoolAha25pihzTlcZU3eJpO5Yj= t5 +qEKe4Dcz2n3Y3LPYWDjPqYM7vW8N+YUFWwlHj4PfNhE/OWYZcYYq9Q0Icb/GFP7Z3I76dvqEjA= iq +Or/PztpS97oLLcae1dnzCClLsAcI1Nr1cG5zYJrPj/vm3Y0rT2/GyKQ90APH3P95IG0BnPJagX= as +c/zxtQK7z7cXDqyouaVGOqim04A5tbazB4cYJDnny6HEcA3AAXbOurggdN5GLwMdubZ5kVx4rI= eY ++foCExQrpjQFOLGgEXs05CSbwjWQrB2108Eun81w6evwYAjRe8bzZLPjnukZoGYEvkqmhJWZqm= jA +l5sfgMx8L4O/5I/hnhMgwwsY95wK0T3H5CoZolfkehzyT5ruk6VdRYLyswwG42eJSs6pnzH4ZE= lS +A9Jmu5ktFpa8KUIWIhZu15KPX2T9VZFJUidCdpDAhBVn5ddb+OveJCkJyVV8OSzdZNPncVwbJt= 3R +EEw8jciTeGZUExhmvWdw0Bl2UhjsMPWPQvX18UcgfhG0U6HP/hr6Her4WhNCTEwKKrEHPddFlw= 0j +O2QWR9f+jn8pQpDl766C+9qtlx106vFcTOVqWUju0pwAGwVy5BiZ+SiV5lnzDxjdJ4idpjIbLy= XN +5J7Bc9RS+OPJ73r1bI27a0tPZdSSey12Z6P0JzqQ7UxZ+5EAlDAkOwHGdcRYQNeJq+Iq/Jrgqh= Cx +4T50FaySsvIrG3/hRbRVJv4OC8ov5fprzY6f5jBbaNuWId0OXXjX3B2JU9PlXoNHa+SUgYOAIC= Oy +HsxHNq0vaA8rbnMCXnTrqFr1PTBS+4rqkycEUqUWpJwMgnQsuRMNmpkysZDdUPjUTR1bDgxXFE= pI +Be25XMzndoLag8HLrShVsLIxUkoG1jtL5VFfIhRpML/l2LaI5mmsM437sc/hGNIedLFS5HW5Av= G0 +HT2l97HdI2Gu1D/mcsxdLopwgLx9aw3qO5+TYQsoOvjD+ATGNT0Lx6Cnrm9NY4BnIcSWXewrNT= Hk +gjH3i2dKsBsZnGAKUDiFM9mqFyv1NsFzseOKZyLjbO7hAwKwmmyUIuMUAtgK4JuM48oeavAgAN= Tc +ut22OSN9ClKYf47j1smCFGmsxDBORsCx21zdNzIGmx+UnR1SMUxtmKY2VVDQiTrNMUl4RbNHvs= SQ +6L+wDgwkdRpqhRNwK7AdawWPcogsJ5vh9nOsMT4p0f6wKWpf4jNLFNpMbtvBJvFBdTm1K2iGB/= kr +KFUKAQD/HmjnKdQ0mCCCuPfcJw67Bh8wMSUymP5RCpQ0OJZqwiOb+O34p9RxBNnmpujHGS0e5+= cG +DyzVRGwCgSibeM7noXY4AZbXYpjn9oKzmkCeTdzQ9ckrtn/j+lX3AgppG4tw9gXauWd0uvv0Ls= Wa +vlbbFMGe7Zj8SBLVWyvUU2sQq7YZNWe9255W3QvmVXPHem/RhmpKZOn+1BKtmXtP3U1whIpcmy= H+ +ZjP3XhKIINCBiJTo5usG23BY55Dfk7oco58p+fKrUH5dpXpTaSejH6HxtQtA6k6CX1JFC299GV= 8M +T7D5Yth+lUHzaQlRE9ny5WI8/Xqo+G3rbtJCUlcHFUWHOnp0V04O95uQLyl4UE2SahNZ5+dwAq= kl +eJd05dn0pLuKxe6wlHX2051f2V2G79wSzz0qQ2ODgmwVZinUJVOMvYN+i3rWdCcdUtLs+6W847= sy +BDFAmhWA2wIX9Qwb4d/uLrprU3YI2h104WvU8kBogCW3ObqbSxa7wwQuRn8wBiSenQkrEXNJ0m= S+ +fFNF2iF3KWXYexxrMYArOyH0O1ARacouSa8XTRZPV4pd8Xw68/yUWTCeQd95vxbPC5ibfqDNHy= L5 +rvMmrrpXCu8lJWFtPNPAYt8sRVN1L/+ak/fWM/g0HNvh6C867zX2TnSgjKaJw1Xc0XVvbV7zK+= ib +3rzvnXCthyT6uUT3KjrvXVvsfJEKlHRvUkILzAKP48yErFWKRSSM88psv1+IFDKhIqTKImQnXF= FR +bgBW1tnJQdY3AbCofUhEldXL0gowlm8rPMJKQrXDXkZ+hTMrKlZGolEVt0t1nU9uXFPVBXfKy7= un +mr71BFfd5RgMebZcA1uoU5Zcu+ZjnidUDSeee73DwbOTFuwd+VNIvd5udq7FC+2CvRVCC0L1mg= NH +IQFkQThvRIBkpwSEvBAbjWElmvsDX0TmYvH+P7uk6Lyv+xJd5Pcyqr+CCJUSqlPZtiyu9YtOCl= y3 +P2bT8R1dysbWQPtxEVt/10x1whqmfKOnAF1tIyWBPVhick27Vn50hXCSwXBto8I2F4jFev3jEs= yp +8T27LSpQl+CVAd34JLL4VbQ4GpnYcyMpR/sfRH3b6LJ/2P0/fPtwO616tiuh7LOEyi456dpGnl= 0L +IB8M+uVXvs5oE14z/PxqeL13KJAdrgSZH1cYTsZA75dVYSUGGl+P+RX+dPKASZw0tjad0+FLsh= vn +i/24Eeh0Yi6YBOk52pospWjSOHEUduQ/I8dQthFOc0AgdA6vUJ4SbroZQsdoXq3AucdcSwtJxY= n5 +kzwkAjfgJWXj1cqkKlfOiMY5QkY8sShiqhwd0ta5b57ZSwAkHIIQcSlh/pRQvb/qcs2VhLlHR7= oy +Hjja7aucCC4wfGot3vVrxl2j8gGmsxMQGeZPCt5hJ8TNPmKmTrCPZka2U7hsJ7MTubHRilS4IK= dw +488ip2ZtSlMp8dh0D8ezWcbquDedMUMxCgTFuP14xBNRfq6gIiB/GnSU3Poth/ENFcmd7Cr03m= xF +UAUM14dRGbTEnfUu9GqLJhnezAx+SV5GmfAq+E6+fImCozQZbmbWvsrqrIZWWTSZygYb3+HJUu= UU +h6my76gbFbZDtcl5dGpT3MfOPI14Q9lYkfffb1wGIgjznkD9CtaUegLL+rv58XQjIg=3D=3D + + + bQDDLF9iC+k3ZjOVlh9NFZjGVsPK7c742dKePJEIOp2w4+/+spSrxZezoygv3jET9S0sXk7QI= Kp4 +QGA985JZ2l8Ktnyw+sSkYKytbT7Ov7gpRoNxZb5MpPmSq9OTXZ6TsMeRo6aBHNb9je3DAK0phX= cI +CT/s29rmOtiX2dhcTeifNWCs3lwAunarrrOf+lO7LxPJBcIXlDCJHMGctOQ415w0EiV+b01arT= AS +vdSuyhbKYp8KCgLMIUqY+XNmr+ySTjM9lFEjglHCYxJOlHBkAn6C4DpDX8Euh2irvYFlUML6U8= fb +JKULJbXnr9KERRhov6KQk/6051VZgKzoG6KEEOEj6JXopVxdB8cyE/iA5MLGlZGysudPHeH1Wu= /x +iJiKuRvTsFA2/ui+SjM6WTFv/Kdz3OJN8dQqnelobEGNjyuVXMbkqlyR/JxNncymTq4rYxNiuy= vj +82mGcbtkXAnxYa7bRH3njaEOzLUWMVLbTDPMxtK50gTXQTs2Cjtjo0l5diTcko8Qsg7a3KXRfc= U3 +6DZPwHbPJlukICQsHHWhK6ezXyKnErs3rcYSgSvMxtSRYWotPu7gNw5TBT4OtSGzN7ztKRuVvZ= lc +3dYzUMw34d+PYpRyTf0/dcARedHYh92YF0fKvdTo6c+w3KzScuZgqFRzpaOZugNddHC8QGDsAs= RI +tGaAlC4qHTIUcQca6iV4H19ZAqWUPnr1mlH4jTSjVYDfDpM+1sLvQH+LCfxeV/h9NNMsEPh9C7= /f +Ry3B6fm5OqOf7mRz5CzyOVyQqk0kcbjgrz1T7aNF3eyLinM10/7AhcDfKk67gHi0oxVoo1nRQl= Vj +DC7LXOKIFAjLKB2GaiagbqOFcXnRt8mEhnAGPurJHaZNZvC6zBONO7YHxHFnRF8Quf4fsbVyZx= y1 +zBD/3FhcNhnuzLk4U7IUAO+Cn5w3+FYRoDaratHbuT3tzq8X9q2Zeoryd0VT401e08NKWrFTwE= EQ +TTxo0RrSM/AG5Ha4dLzQr2PQwRiXo3ScAuOFrG8mTzuGfAi9Ml74EEyL1MiowTOTznsRxqfclh= Yz +44xIl+90YnR7xyhiRrdn3gi32c771Zp1nNqRhUjEyeWbX1X0PJHJMj440JxrQoVm3kAQdrpHF7= v3 +MFb3OpL+dUizQPoI10vy19GATmSNNlgfGwRv4oq6IWbdVnU7ZV8TuCM/gvv1+iDdjusEPhe4ss= vG +2H/KGr1rXD7/GscxCD8fnIqsD776Q8tWkwQlnXEuG8VwSqNb685A49xHqMikhxgRd3Vx1GY4CG= KS +VzLp5eQuX9NK3HaLH5bVgsWkgV/a2SkRsk09QWVcA+l9TozT1jkVX9Ca6llkSO+TPQN8bpCNv7= rF +qZ6himBQ6hk81XO1Yt1GjMSiepH5mSP1cFM9S0ULU4nUqKwQfX4UUoVxyC2qN1eEeVJv3VTvxc= hp +ODyqortPdJSKfp2RF1QQCpX3DLXr03zthb+Yz9WzcLabLja8s8CIHGycbU/vMvYKvtsFT0egqn= Lk +l16B8Sv9aaTWSbV/FQu3ZjYPJOhXs/YViRxfS0QQABMkjWqqSKqmX6RAdFso0NhACn47YmDWEe= BW +OMt10tM8xDhFZ0oaO9PrUmzz0XRp+78K9vhvf3lu65HJpyVJSfGXHFiUGNDgTgTwAZqsRmRa0e= 8v +FkQvReMi39zkr2FSp8ezujFoqIK3uMhXPt//2qEclWdsKGRe2n+0mbSG5vzeQsfc29mEhtPQXJ= gX +blhmu6nxhmYhmnlBENNFRS+nh33uPGAfG2JsEpyrHLgAIq7e5XejHIC42SlmGw5Z+kryWA1hOt= mi +r8ynSRvF/gdvb9hO1URHXmrFyaLZUfA12CBL8LIXCp4C/lPtaf+6koMzshKydAaoSqA7rAS2WE= KN +lIPzWQlpX71E2T1w4A+YauXA60ME7dvwgI4vloJfoelUspSOTD/nNYQB5FppBqpMy9X9KAY5nS= rG +gKj/prefLrBIxTBWHcqYA1oVM1qla016TEGUKzrUBGIGMrQVD0+8AtJmfRnbdymLtVlAQ4UaI2= 5g +mvxJuGQCe+0Ahy5JtM/E4ROzcYq5HnlH1WCPn7jLpNg1prrm8Vp7SydMDHPiWcTvKqWIk7skW9= wS +75+mQrOSoVpI6/hpSXt/cdHCOML0nIQ0a8lmlZdVm+3RRVG6puUVlJtcElXGoluUV1C/wVB43t= 3N +Tfno0AWbYhWi1q5V+EwU/5viaxMO3Nfi03hgTdI3xdtUhUd6ihA3wReEK1rb987auYu91J21jD= tO +i6iC3M5aRTMWV9JRx9zcIwvGP/ZJ5AtaAl38wPQFIawwsMbW9QEoq1u604mafbCqy0UJmBhtoU= F+ +mCoRnk6G37pvQbwzw/XWuP7BQnT9lpSUbasIONYRGZC7puZuc1+4mtzEb+7WV8DdIjdK6XV9HA= oO +wcf0aoKPQbj26pGL1P96IoJDIoe/0xeV9LxFQJAy56oO9//5CwfzRfIG1Szzw52ct1VbO0OHJv= Ej +oO3F5vLq5goB/33Rnj/DlFh/PReQWA3eY+cU7YSU2378675/UVzAblU2QXoNHdj5ljl7yBdJde= hd +PmAKYJbm4u1aHkUAurlSxTGEPi2Z9cRSMCHVifGkvwj7XGk7VF8RgfOoIiCllND/NfUR8D6Noy= Ig +9f/+vWQDvl38Gt0so2bWD/oHDXTstuPrfdej5ATE/kKjf6/sFkGnCfHTo+pf/OBLLyhVjEEi/L= Dq +IQM+/hA2txC8/eX4TEvbyXMsySGcXGLZH+ttE5zeq49D37IO4wjqO3G1uTmm3nftwa7T5sSBkM= h9 +CzYOD4Rqc3YKwvAve1AfzvJKczADemT8j24E5+EowPF1Y8DFQNPGCkUi6zLnFtAjBZxBgFEXqE= u5 +KqRR+JaLVrXI8Ek2YO0U0Xx335HYYQgFdqYZjILxdHX/yLq1GiNwkaDxpAxogL6/hQhF//wbFD= nu +QXAqdyq38Lt1Qkb1gFisnMbOetsKtSONzFS5cIS7J0FFsLptLrHcbsuqy6/cdei4Fx5NP0qULu= Ac +RzxRP3auxVXujZshMeSD+NZiKtaLUIN7Ipzi43faPN+owSVfWYwGXODQe1RzhXryuYMS/09I9o= sS +zLJkkw8l8NH6XZjL6+1tPgKN2BLhlzrNv8rRN/H/m07N4m+pd45qDsP0v2Z6S+VurwWMt4E2k5= aJ +LKLLmALMcwDJT79M/NwS59hmiloBhOmnV76sTqmXhpcdA8QPxYX0y/tVzrbmMl949CtV/bEiX6= 2n +pTB6cXef/x3KaJgDOUoSAJOeDoERqPOYmT3K1vcyF4KhiY6LQ5zPt6ReSzDiZFKA7f0fhF4nt3= S8 +jw3sB5OTi4KvlNIv8cd+sOnnSL6kyfza0nyx54ST0mBLuNWy9/k+J3KvtKHi5Gs2JN+rc0Mp2O= Ts +hnLiCA1gaou7Fv2aJ+hdhjN86QuBqVGnYLlgv3GfKJGJsiRruGhX+bOL/JfcXyLQxVHQy41hCF= HX +Hs1h8zWdiRzWNjJKzuEsDyJpnoG60PUUZvP11A3HOTA1yIKR0YW4V7VfPaBDUm8WwXJSOAQ5e3= Cx +AXJLb3jv2iz9Yh8dEkqpmRxQxhGOZmGGchjiL62X5Q9cc9doXZlo//xBBl3b+DE6QeBfyGt4Qi= 1s +53RR/4khzwV/KT7IX/gPtYwdWE1DRy0X/MK8A6butkrC/HsBwS/E3xWIQ60raFuM1g/SqLx9eo= he +flwZajmR0vaDe+0DNlJqMPM/asWXk7/VK8tWlgvQeew2VObsRPr7YrZoE9qiUB7iunvgnsNln9= yi +LZAx1+Lh7zuWpd/7qe5nRf5Rmuu0xuk2K7LcCzNuLlUZtNquapSltbcxTEpIG3uCXE3YWoA+Xv= B0 +PwoWRmz2cyr117WTmiUFPzHyq8QqRf0k8/MsgZ5kLsL6Fp+OTD2vZaWEfV7tr2LAsjrKdqTqOX= FR +N4fIUT1X5rhi8FxhB93Zz95FukdoCy7FWrbHoyfuiI8+TqTQX7TWbi8g7dvVQRL8rrHldC3Xs2= r6 +VCHvJJC/92l2bw5/h3i2lAO4fXLD2XzrkZ7xligdsqqbg39rADeDR93suh5PaKKMIvczPAFEw5= s4 +WyWKfFLeN1hWW2oEbAoUuZeKvqjqImKKXNSZOIUMVThLasib0mmZRelLjfxVE4a6GGWLkzESpD= nT +3j0Ye5l3S9OtH2jtHtJMX44LchNFte3dQzOM6i2d90s3Rr5Py68a7eM059K++NWwLTLv42qzDN= pb +NGDy68r7OHaXYKf6DvnVE7rZ15A3iPHHNR71EfdQaYgMITHIhuJxIQjRRX6d7mmUOB7PejQ/2V= vI +Lyeyv3wAJf6NlAxRdufTd3wiZ/4tq1uXEyhpvcHU8HUpZ9PihsLcH+1deKqhqL/GgABBDgFpPA= L7 +FCYlmxdfc/PNJs8ZNRJY2lpuADgAMvUlq6d08n6Aq3c+6dofpD4CAZyLWPclD0+6Tku+Mvv1rQ= W/ +B8YiVFJiyQpImM4Iq2vzYtd4uUmzuvWIr5cp4PKU1sWWZlXhkrhoiNB+G+EsQwBEiuEFKjthdH= Tk +Zt9Ws2BD0fWo7Np3VQo19QJwFW6aK74x7RIEPdgUKHe57W+prw9ns15wsE4jhSEqnC3CyAFgBZ= 8F +NWpc5WDq5Emy1kkIXJ70y8IKEWjhs2uw+mLrluykilY3OsBHF3aAvCXX1Gs3NbuwuElUKehCKk= hy +2QzziMYv/LOT3ZuQxTjsoMcaio2RbPt87hpmazw8X5ZS1++hrbNgyOgvngfD/x64JnzYWaRaa2= UM +xnDXbx/htOXPlMnWSK0pGaxVxMUSCphCHC9CtJIQrSnd2fisYqHw8WiNmj00p7SFY57SPFSJgM= 5k +mUsiY0Auzgq9iOzi8puDaF72sbMapVxa0G95vr+WSJoWiKxWdh7xA25IpPd3GATrq2oTFgDa+B= hr +TrFSBND+3GWZy6vFZktw+Gd8fJ10qKPjYo8jNTry3DEs9XgGgIZvygGCngqRuyaToNiJa0SKC9= sI +Bqo04KHsD7TeEx9mKnlqautK3ZJPjEgzUdVLcS8LJL5fTwJ8gTvWckRwgupW1vyJIcfUcCluth= 3/ +yj10l9WGf+LaFGdIhbt/W3niZ2wcTyLGIMUQ5XOa8Yk5lmJGXJ7+M9acGCNSJbv+hyYux/pSOy= e2 +44B6XEQnOSqZYy9h3uOJBH7idCkGGS23PK9xVwmQlkd+i9g7BxNws2E371EYiRx7H0CrLkMNzX= H5 +kzMkLX0ARjFeSB1QlS0pynOTMaORwyX2kSGAJGgUhur2Ln4pFrdrFISUHCENi3TkMkj/WethuD= du +xbmF+1yo+w72bosmuUmkMhaRsJWxWFqxVn4UOQ+LNzGgZiD3W4ydNTtxPmPRWWL7h0XQTC3iQb= 2o +Gi7kyqbcw2nskYTYElsfiReg8RJbdWADWO50/qsqa8ItVvGHPWOx6K0QnkvJOJH12Q=3D=3D + + + vOXOjKPoKxbqFTw7/kc2L7pGS8UyjNEkwSTHeDiTr1DXiL3bC0F4xha7wlmC68bo2KpKiJo3A= clG +cz0FtkDi0+kGh9e3Ty4HjtJM1rcWUkeYZFe5BxOf4a5neWU5bmq1dwWzu9iaVylKAE1C295d7p= rX +YwTBCmnabUYN4S57NEAeG0Do5mobW4FtEhuAlfEV3AisGXcP7tRR8ZVQDgImAVajGqZSrVYt2E= fq +R3L/GNv5katux4ZIUiI9EuiphKkH+PiqgC6JoREBHJH0mNARCSnJmfH/7UFy7qqmtgjT6kHUVF= 1y +ai8BBeATDWMo09AwpMDukWboK/XxHzQiOs0egbrRIgkboYdVq4P6E29EQK4pSg11Tpo+MjpZMx= Ii +oePqBK2yX/WUHX38aCw99sB28jeoUPRs+WEBmgQR82FurnxebDxcm1W72thwg6NLPUZVnivSc3= nH +KENQB0WMRAP8lQD6raAqSyDOcR61FVcYOYmeOU9Kav5DSF+MxVIuAz2/dPipbAfi1cy/AQ3CgY= EA +SbKMQWgs1W+aXfir7LWZKsBbbtqUB3Yx8eE2JzaJjMiUAqsCewKkAkpKXq/3+/1OTU2Nx2MUKF= Cs +WLFiPB4bYIABVlZWUVFRWVlZfd+Xy2UwGIxnZWV9v1+z2Ww2m1u0aIHjOC4jI5OVlaXVas1ms1= qt +xnH8+Xz2fd/3/ff7xfEYMWKcnZ1lZWXhuJiY2Hq9PmtpaeE4BBBAUKNGjXK5jONlZWU2bNjQ0t= JK +IIEE4ODg2u02GBgYHR2d2+2GAQNG3/fn89nOzs5sNuN43/fv99t8Pp97vO/7dDqtpaXV9/35fN= 7a +2jKbzWg0Op1Oq9VqtVqNRqPL5XK5XO7q6gIDA7PAAgsMDQ3P53NXV1cDDTTw9fUlQ4aMIUOGgI= GB +dXV1pdNpKysrLy8vIkSIcMABBx100IGXl1c6nUaj0TgXF5cDDjiwXq+LFCkiQ4aMr68vtVqt1W= q9 +vLzW6zUGGGBgaGi4Xq/DwsK4uLhUqFCBq9VqMTGxGjVqjI2NhYWFgYGB4V9fXzRo0ODi4ppOp0= hI +SGJiYmdnZ2tra4KCgmRkZDNmzOj73szMTE1N7ezsbGxsjM1mr62tvb29mZmZsdlsHA0NjYyMrK= ys +zM3Nzc3NLS0traysrN1uy8nJtbW1mZmZnZ2dycnJtbW1oaGhwcHBud3uuLg4MzMzNze3Gzdu0N= HR +wcHBpaWlxcXF4eHh6enp2dnZzc3Nubm5eXl5ud3uvLy8uro6OTm5tbU1Ojo6HTp08ODB4/1+u9= 3u +t7c3Mpnsdrv39vb8/PwiiCCCHDlyuN3udrvdbrf19PT+/v5+/PixY8eOu7u7t7c3Jiam9/tdV1= eH +RqMnmGACHz586Onp4cCBAxAQUFBQ8O/vTwIJJODj4xMiRAggIGCPHj36+vrk5OSCBAkiRIgQHz= 58 +HB4e4kSIECksLDQ0NBwcHAQCBMjg4ODa2tqQIUMODw8LCwv5+Ph+/0eYP+4nV0X+BHDZdStanh= JP +Mj7cLo98Dvr/n+WPyCLA/8uqSJoCXFhhhlT6/jFy+CUjMcAgAjnDLpNm5P8Tyi+88mrowv9HBs= cq +ezL9AQctkrtuLBLz/Jl3xIS6JAMK//+/ggGQu87bmKHQAfsDrx+RUHx8UMhcph+hMOu580Fy/9= cd +8UedRUWR//1QOPOp2P9rHk66h///7+a27DYu/v9/7HkkqQa+wAKN6vK4u4SNHNlq7jBvIyOcY5= JG +/agkyuD/H4ILk6NuJOZ5koyE/4esSOY+fDC8QMEAxBcaAIqRO8/D1oIRPCV+Rw4wmLeE3PkNXU= aA +kIXguXpyOvwxLxr1XYZFCWWeXTcW8/zI+7SV9fDHon5k8XrwA1NkOOpFIjHfb8A+2M1eNB6XHj= Bw +4R/RkbRyNBaJuX5cUaCE/0+A0XLUi8Q8JxKNOrK5p8InoaxKohuJxLxo1I9UF/y/AQJH3ZgTi0= Wd +xUYJn0hvoxeLxDzPjUZ9/wcZG4nEYlGp5cEHooKlWCQS85xoffufBxOReExxAR4XSczzPM9vvD= 5d +UJ7nOZ7nOZLg///b6MnzHGeyeOF/FthRnJr3f9gNfuI1MsILJz5ThuWC12yj+P////////////= // +////8Y8TgAIFivF4PDU19f1+vV6vkpISl8sdGhrSarXZbDYoKEgrJCRUVFR0dHS03W6RkJC4XG= 63 +211aWmpqanJycnp6evp+v2AwmIqKKhwOV1VVmTBh4oQJEybCUlJSYDD4+/0+PT05OTk1NTUtLS= 11 +u10ul4uEhLTdbo2MjIiIiIaGhoSEhIKy2SwQEFA2m9VqtUNDQ0ZGRtvtlsvlKgXOZpNmJgbmxW= Ul +5WRZkuSJyJJlikoLM2ammaHG5uYGBycHB+fmxqYmQ3MmhtmigrIsQRJznkR5ouLClGlq2IDDQa= fD +zpOHhwfKw8Pz3OmgwwFng4amDLNF5URJwh/1ZIlJCguTxlmDo9OBJyqdUqvVqrVarVKn0ihPBx= 2c +GqcMkyXFpCS56/nJiktMcwOOzjNKtWJ9AvDw8+HHQwA+WCs1+tTBqWnGuKycKJMoLMwZDTcdnt= Iq +1sOHECOAstkgbVA2CzQixAcP2Kr0qXOjYYbJgkJTk7MzrWJ/QgAFCREVGRkdGRkVEQkFAYX4wV= aj +Ozk1NDAcnlOfHxFZoaIjJBLcpG4SlwTSUZFQVsTPdfrkENO00eGh+oAAEjLacrtLTExNTk1MTE= td +7tZICAiED5VHx6YZw8Js2ugUHXG7TE7eJyioLxTUk9eJqcs90rFpMlmYNDUceHp8QGSJSCQtOT= 19 +S4DBUVFRUlFRUWBwie+T01LSligLwqeHh0MNDRNJYqLyIpMBZ2eKBZEl2ioxeaFKRElNTVFNTU= lF +lYDyMnW3RFkQ2OkOTgaZFxUTEmRSidIC49wAQNT6M2Jom9Tk/YKlpqjC4bA4HA5TTUmBv16mpO= 3Q +iB9rFIANTpgWFGWST5acrLzM1OQ8qT4htEbcJe8XLEUVFourqqqqxOIwlRT467TENdKG8KE+c2= pm +XlZOSpIky5QWGOdNB+n1Q5YIqdv0BUtNhcVVVeOqKnF4SgoM1dRFIsp+uEo73DhhWlKWJHyJCB= Ld +Jigp8YkUK1i0WICMlVXuz1roNFrr3JezsMgLtGCxIsUJsRRUU3cLLUHyxHHgdZXtEBhe6CFuaa= aP +HOFy8stoEBZSoCNSOTngAxRksy4FEMaoJOAKkLvLmoR/iGWzD+X9Lly4IJPJZrPZbDaTyWQGGG= CA +TCZfXV2p1eqrqyv0FdbV1RUajQ4LC+v7nourq4vNZgsKCsaIEWNsbOzu7s7tdrOxsaGhobXbbT= Y2 +tja0NLU1tra2trm5ubm5OT8/vx07duzh5XjryNOLYAceHt7e3h5f3wR+fz18/AAEwsfHFxgYWF= hY +SCg4GISCCoRYICgoSEhIGBgYSEhIWEhYWFg4ODi4t7cX2NfXh4eH19XVtdfHJwGPvff7/X7nyI= GH +d3dnZ1dX53bjwEFHd+PG+/1Wq9VnZ2dt7Tm5OLg3t7Z2u93W1sZms9PS0thqaWg2zszKatAgg4= Ct +pqbGZrPX6/V67AGxGTIcMJvNLsxmc9jW1paLdDr9YiuN1jr35vKLMoysF1tbW1hYWOQX5CSRV2= ml +9lCpPVGpdeqkXqdRJ9gp7ZE6p1Dp9GqVQqvR6vQZhUqd1qhVWp1So1Uqlnq1Up/QK5Tac5Verd= eq +FWulYpVJSgKUTsoTKY6OqNQr9gq1RqHQK/QJhVqVKpzUqdUqpU6jUKgU++y5Tq2cKaioTlilED= Ge +Wq/XnrBYTBWHd6zWMXZHHIVSd67WMXZnio1CqbDXac5YACoVRFiqVCqWVlHHUah459ojpdoxUZ= 1S +d6quU+gOdmodX6vWKtKQV0nFgipLJOY5sVgsGo1G3Wg0FovFIpFINOr68bjvO7/v+/Go60ZjkU= gs +GnX9uO88EolMJkmSSSQSye/7Uc+N+nHnkUmSEqVyuTRZLpXKEpIkkt+PulHfeWSyRLk8QUFJUV= FR +WVFRUUlBQTlZKkuSSH7XjchkidIEJWWFpcXlhcmEYTJfXFpYVlJQTJQlSX7XjXxSuTxJWXF5gY= mZ +oWk2nc4MzoOBqNKbyDLFjJyISJIkhQ7iC0iEEAZSzJhJXQwSgJBIEERBCIMgFANhCAIhCIMgDI= Ig +CIIQYogxiCmHlKTUBkmG4+3ASzefedjZKi1Z2gHhr6qnGj3op6NPZ/o2O6CkK3sWkoJBU+wQB5= wa +4TjyVFzGSZ0YYb+KA01BUBxsyiviqFOsDkeF6l+4AhnvcIuFYvDcgVTuLaBzg2Vd1Hf5/K/nMP= fi +XLyoyqmXn7hJLIBvd+mAHfg3ujOn5+RhoIOyE+5hngPFw2TzcKCyJd/3HajfqdUhZ5EZEQIRFC= nC +iPgOGC6FjQXdRb3zWTaIXfwC6qLny0iOZi+2Nrq8JNHo+sIdo8vL24uuMv8surxIqli0mUWWDQ= JX +OyBQvBw6hNm30FuTWomttBZQoWLoDtiH50BJ+9dB3fdOlviVgEQmS8hFyEuIRApLXiYCUEpNCw= vb +DtjHf+OTlwKIFXCrYFdhyArcK9jXH6ZxPlSNHfDQ3nUrP0rugH00ByqhNXIDigDQjlGoJzkm/k= uC +SiZLWFYCENYO8Md2HnfncHW6TVRsQLeZik3pNkSxQboNUWxKtwFBm2DCtQyfiR0ojVtrH6nWJQ= wN +hmolwtBhQIeKTPwOeAg6DFYlEpTiEmIUEpSCkiIUhCVlKCUUEDrNYN8Bwdm0yF6LTipsVAitgr= OK +32mBBsUPWHeQVzNrjQJ34y9tWIOwMLHWsdSxlLAUsVZ2I21i9LHgsQa5+NqB9U+QfJ8xHY5aLq= 14 +ExcealHWPBKsRC2aLumITVoeXFl0wVCLtq3P1LQ2vw5cUiWXo1PXF6ujWM9FxdgpfQLLBcxejj= wL +c4galkYL0uzRapFk9D5Wdr/XaIn6ikKqEVoRpqgcLbofY5ZLhn6/MovuCK1oSTjno20XmM+l3w= Hv +eQJ05ztcB763wyaA6sXGnpXy3AMS0zaKf2MSxi/xmFAW9BZmqvE8QgA2UO7JZTW3Nxiuo2399J= pT +CdOBBxmKzEHNGgtBm62cmMjnKTQagPs1ufDLZfIPDaQbE2PgjjWdjgCfIvNxf+m9I/pJEZ3iET= Rk +1LHpmR3wyrcToy4jaDDYThyREAc7Xqw3GIeSaVK76FrpEBMU1UmcMQ6mnfM2XjsTggBOAoRjbS= Zu +4tyVEC2W3hZYMBwATZtr3FMeHDyOtOY9XnUHeXA1mlBx709QwpyEYYZ3FAEYPrtHbwEaYwOQSY= 5q +mUjrnKLcXDjv0ZiHLPA4IWRiDiaf8N2RBY2KqeanwHAMuqyJ/BI/vetFdCD1N2tiuj2LRTNZ3w= Qw +wHz//nkcC7EbYLVUTreYIh+AqVy6/Fk0IyC1Z8nRREwYC7D16MhRf+0GkIGrSRmvbw=3D=3D + + + r3AJrrAZR2RrAwIb9mgvg1XsUzB47iwXzkcH5hrem4LBpbreI/NP1NVZ0Nx6tTc+DCYgSGFbe= 0i5 +ucjtCtNAkaGXmAYG8ev00ocMZ12We2Q6C3zeKlMAvAareE1Wqqvxe3D7U1AVXBIPLAiOAGdeIx= I0 +RWS57ZyK93YjgdyqD7Cok6G8CWBgsKr7uzoErAl1vN+UV/yfj4k8lzvBVoU1DPhh3dzIjA+j38= jg +btXh4a3fZBm3gKOCNTeGhYm6qUbPrYGom4LrxJikZUxfAaDujB4Ha2H0BHoJGfWCxyngzf2DBd= 4W +a3CycIAjeJoj7Uz9EAM0kdwwQgwFYyHJnmyGEDjKC+eVp5io0Jk9mIXK9Q00FI9gvmTmZF8MZ3= 96 +k4nC2WTu931ko6XVb3ymI26b+e32i5/IQEfMRBK+5LP/9fqfyMNryezL8M0nXPWjP+1yTvjcV3= DA +p74GJ3zuCzjgc1/AAaV6CX743N++2Ofr41VK+VTf/4kMdMDS1MV3I5Botf8e0TK8Jw6RJgPG1A= bz +WYyFE/LQZK7MfUEpMfaekBD93FKxqOn7oqxXRO17XdmWmmp42mgkkepsRvGQfENho+u7Lk4Txm= KD +j7AZ+8iRLA5h/PT/aSpVWRM1gA1RGY15fiKwaRpzGYjUzhLhKnmQqchEThPUKfUayfkqpmF8N3= AE +bKZx+fdosnNOwvsEs5LskrOrkecLhSUJf7WmJW1ySVLQ6ciiyK+KZM4cV8JOmZBMcum4+Y/Q85= q+ +j430QWqzH6GYNPnlgYITSfYBivGXJKhN8cUyVwciNQOJ1oE8wBVZmA5zTa+VSPps23F+6Z3idb= eh +jvDQn5cU6YJ92U/tkfi+SSRL/I3kQPf5KdD8IXwcdYlZA44k0kSLKn2nTPQoQPLhrA6P0Lg05b= z/ +vDQbacqPtbLTdQ0VatGMlVVSKp6BwoO95Am8fKCpCqV3i7OVFo2KpFgpY4JLzY9SdiElN6A2gT= 2/ +Kn7TFAWqbUJelHJ6kW9iRqSs9QxVS5cO3dF7icGkB4y8GlvO+VEOOaCHYUjRMHCGzhWHgbA0Ma= Vs +WgmVxAQPqWu4dHa5iQVmbmIJSg9/KRq6Jk/96Vk1Wbo0GTP2gCropYpYF5S4yAG3JJuYLGYc07= Tb +X7cNLKumDKQvWXGJxAjufN3cttjXpzuvC3yieampfmpjz4oSTTTXZSxBDM9XsBLySxmgHWwY0/= st +h3kAXSSwhYJNpSvba8JP5CPeuAEsmxgYI/BGVnRvUk1jDvEjYaQFItOFt7RYmsQFZtMJvKeqhm= d+ +j/DyfIVP+3yqz3U4lRNRoSb/wuBZXwT045WvfkAioll/SHin5GJMTTAtiLCrT7wEl0Z+abiTBr= /y +UJZAqTZFn1jyhw8/CVl6higFjlNler30N5y+XggwlAUANAT/uLi4ra2tgICAj4+PtLS0nZ2dn5= +f +tra2wcHBz8/PxMTErq6uqqqqjo6OhoaGwMDAvLy8tbW1l5eXwMDAoKCgtra2JCAxx39jD5rjgy= B1 +DBSAfoQjAvpcw67GA3CF/JCDfOkD/SCCfrxAP8JAfpgPD0s/MeAANoMYmIL9AAf2YQf4AQLngF= Am +Bj7QDgt1MQAWBXwHG0IMnIH8HAHoYGjFgA/ox/b9cdP4vz9ypakqVwwGAIQF/7m5ua+vr7W1tb= +/ +v87OzsXFxdLS0omJia+vr42NjZycnKmpqYKCgrCwsL6+voyMjL6+vrCwsJSUlNnZ2aGhoYKCgo= yM +jIWFhZaWls3NzcbGxrq6urGxsR8AEUAdOwD4cQGgHwJzvADohw0E/DiQRhCAfhwB6Af2gT8AAf= QD +CAB+jADohyMA/FgGwD6AspYg4MAfGBggMI3qA38E0ADeeAHQT/iBh2FEEYMDE1QBNgAyAPhBAw= Bf +pgD0pQkfXAGEBAAEBP+0tLS9vb2oqKiLi4uDg4OysrKLi4u8vLy8vLzT09OKioqioqKysrKbm5= vM +zMyEhITHx8enp6eKioq7u7uzs7MXAMkBftEA0A8xAP1ohIAfjRDwA4jDB0A/JgDgB8A5UgD0A/= gB +ihEDAD/0APTDAUA/tCDgRzUE/NgCYANVxDDoA9CBHKzYGIOAL9/74ArEBQBEA/+zs7O7u7uEhI= SK +ioqEhISenp7Q0NCFhYWjo6O0tLTLy8u6urqFhYXIyMiJiYmJiYmmpqYrIOHGTDwTUOoBmUAFnA= M/ +gIEUIIfvMjEgieiGwwAG2kA+tOEC8gMc5OdPDdDDIMY7AAj9hB8+bKY9BDgTNEguQAEcoB8N6L= sZ +AwigH2GAH0ewHygQB9FrCTAhyMgOIADvoOIrBpghfuxAP8+nh2FLa4CmGQHQQQfEgALgx7EM/Y= Ur +7AQARAP/hoaGhoaGpKSkysrKiIiIiIiItra2kpKSpaWluLi4ycnJuLi4tra2rKyst7e3t7e3k5= OT +IyBBx0x+6wHpg4dBk2HAQwHU7w+aUwUmBTQAB+gnC7YH469HxwdsWA7DpKKBLOiHPbiPI9APLu= hH +V6rfH5emC3KggZ5m+9AHzoFuTI4O6Ef7/eEU3Sf/5cO+qR4QAXWYwBcGhvWDKywFAAQE/7Gxsb= e3 +t7a2tri4uLa2tri4uIaGhtTU1IaGhra2try8vLW1taampsjIyLm5ucjIyLm5ubKysqamppqamr= W1 +tSMgIcdMPJN7ufAB0YYwME4T3A46AAP27yduKAdukN8fjg4ziC/mwD46oB+7AD8wMA6PhIIBbn= hD +BOgwaDINBIF+eLMZ0RADGoDrAB5YqxYMHOAeBk3GAzY4BwTtwUBXTvzXFUQGAGQE/4mJiYmJiX= 9/ +f4WFhbS0tLq6urOzs6amppubm9PT07q6urW1tbu7u7S0tIqKiqenp8fHx5aWloqKioSEhJSUlL= Oz +s7u7uyQgccZfiWoCfBLGw8y0afAExmEnyDWw5/gD/MB+f4xN5/w7IB72I4TBjIhwsEmlUSIAPg= AH +2A8aqINOlGOA/P5Igf2wiXQfL7AD6msJ4RyIAH1oowP0x85xBP3ICu/T/vowq3sOZMAdzNERVm= jA +Hhh/Ip7+JKVg/JWk+1A3X7gCFAUA1AP/mJiY1tbWi4uLsrKytLS0vLy8g4ODvLy8urq6i4uLsr= Ky +qKioxsbGgoKCnJycsbGxiYmJvb29jIyMsbGxICBR5/9qB1DXDyPAzylhMRUOIP/+mIJ+NOA7KO= kF +BiiNJYgfX9DPHACHHSSoAQfoBxRsDgumxwD5/REc3tCAfmTBfoyj+v54gX4Mwn6oA8afstMf33= gO +0KcGrgO77hgcqMQr9AQAdAP/goKC19fXl5eXsLCwqampxcXFtbW1vr6+xcXFubm5sLCwjY2NlZ= WV +oKCgv7+/jY2Nzs7Or6+vICAxx//eA1DQj0nIDyvokxrWozOA/PdHL+THAvSDCekwxhcxKIXigf= EX +G8EfjoAfL9CPAiD4Rwz0YdQbBjB/fyjHBYhDqqfEwAv0o9BBfn94dKgCe4xhkzEMIBDywxD6cY= Y/ +XgF0BQCEBJ2dnYCAgKqqqsTExI6OjtHR0YiIiMTExICAgLa2ts/Pz8PDw8DAwLi4uNjY2J+fn6= ys +rK6uro6OjpaWlsHBwY+Pj6urq62trSEgUed/e4jZDxHQYQh1MSAH+bmD9eD869HxBzfQwvugQQ= 8c ++H9/VAH+gEAf2FhBOoyIBwY1QA+SEtIBEcAfXaArjzDAf3/oaUCADtOAgYH5+6MbHbAfF9CPmA= YV +5IflKIC+GAJMGQB0Bf/Dw8Orq6u3t7fCwsKDg4OCgoKWlpaOjo6Pj4/CwsKoqKi7vL29vr6/v8= DA +yMjJycrKzM3Oz9DT1NXW19jHx8e7urm4t7a1tLOysLCuraylpKOioaCfnoDtqJDNATEFUEAERF= AM +QkYJZOgDEmjACDqEgCFAOIKGoCFoCBQCiGCKAEEIIITBIAioLToP+6Fhy82BIF1G+AfARvG1Vm= 8g +r1WbWxgo1dpmM3Kas+GzoFRki0W5KOGF3XoiuswmRV/7N583AaUo4VG+KEUJj/ItCU6QkPDbN7= gg +mC6LA9Jd1jlCXPaJq3BvVYulH6iwBZuHsbaoMSCrRd3iFzK6MdfYuVUv8cPQ/TFtPCIEOyBzfi= W7 +0qzgK1eXZMVfma4kVihGhV4jjQgBIZtws5wk5y/yHFjcPpd5Uop8toToinNgClb7TJrG9W1dG8= +X +zf5cIyoZ2q0ZwtgBvWNnK/8Q6l46INbbDVzvGy47nxHN7LAY81zmscnap7fSJ/Q+/Sk9Uv85Yw= Ro +MfYC504mLtbl8g/67UDtU3ZW3usShIgpuYvEoHmIAojtJtntsN4hbBsmSToyTEacLcw6ZIXZEn= lo +MpXMgXXciBi+DQ4vGRWyYIytjBNsbRYZgp3NEjiwsVmgBXayfAjsf91DQmNSeNHbV3R/l5qQHf= Aa +4EXYEcrzaiY55UUj3uKVTAbBq0dWvCtGprcrmuBlV0dArqubsaauhvGhV+R5HUlk+iNqGOyAwr= 6p +JL1f7Mj9n8AdAJdVuPwzektmXZYV9GNZEyM7oOT/h1vkyNfE9t/qPmC8TEjNfPg43wpkJ4Nxxb= xa +rcAfOwkyrNZ8KTsz+hkjU61S74CyQTbISUZBK0OmMitAPhgasmIihD/TU7IK81ZWVWe7HVD2Om= +n +QJgfkY1OPVFAUcUgNaEyUfNPORFMT4lJcQB1ChLx39SJvmrqg4plajqQw9T7LtlTbjSqKLADNR= 4H +Dp8R4UC3unv1IfeZDCnTMZInCmf3ZoGk/4CRCOwogLVqeS6/a7NRRrS/ruGT5IvgznwBhnyBAh= cI +XyuwP4EbAYjEPnhnZ0YHI38XcpMtCeQDAGCWJEBAJJGRkaCgQEAcADNga+UcrsreMchV4dJ8AF= t1 +6xuj43pj3vXU47KfI6218m42gD+oABWP1Toj/jgs8E/buR+K0T6jfUCrQAQghh8nD60g94JQ74= ZW +QRSdoSmIEPwADqWoIOCE/fyQQVyuAgUQhKYwCHWtgOT64ApMAAAIAAEA/P85EAJMAAAIAAEA/P= 85 +EAKsAgAIACUg0cf6d1cq0BDVDzRE9QMNUf1AQ1Q/0BDVD2mI6gcaovqBhqh+oCGqH2iI6gcaov= oD +DVH9QENUP9AQ1Q80RPUDDVH9YGmIqv9DWUsI/yDVmcdXfI8Biib2gFMQIEZpHYF9gf0XWTjzFQ= Ca +iFNYy4caEyFNdh37PjWJZTLzrrtnEEFL5p/WJddZkA5YWQa/ZxHMjytN48ngGpFSSillSqqlKI= Qz +0L0iIDoIB4N37BgHdwgwCFIo1ZosclaHlu7kdch1lbwODSktrVY46ETV+k9Q0yf0S0m9ceoeg9= 2h +Z5tRzAysayksawsp+LX8WiJ5zW1DYtfQW9rfMksy0lpa/aoNazkzDV3NSmmRFbzldFRVVrV2lc= rK +krFRTjQ2tOi8Btb2BB8hbbXCrZONZXtY61WcNmG3w04hmqlkPSLNqMSsR2lVGcy0mg=3D=3D + + + FY2YVrNikbFrbtLO1N+fskospZAW9Hc57YkcCo+GT8w/ZHrqZWnJtKYfFiRzFiHrqQ67MdGbd= Aus +DaklxjFTigXWhoSbSOTQCOqJHJJ5xUekmdpTm/xfarAcC/GkJtmyJmtib2PTeRd15Ay7NlOVVl= KL +bQk5lJmqtJJuRW9Xyp9mRfTHJSsi6FiVndYUhYVlPUJtKbSHZaNNzCPnmzYJC6O+Z4tS7DJ71Q= Wl +dIuuqSnHit6ulMSkpe/UmMraybL6MQm7bWO479qitqlvFlWZHwkOQvUn2Yrqbf986sQsXiQrp5= 7Y +YgxFhBwa/fOpH51PqWIbfTRtaru671OiNyrllmqGpQw7JtuSVLaarOlVrb3qZFGKXR4Fk4ScsM= u0 +jUR1VzVKRLYkqteM/BD8dqVEEs2ORf1ridtLclRzqDSV9vsRaxuLmtCk0B5zBaE6vbWaFWPlVV= Qx +DSaD9uaW1K0Ju0lIrLEjWbRK2pR05HRM1tKPpdzyWjIzDpk1U9GV6UmpaKroqymoRIQcItW0jO= Qm +LrGn37pSuovSzIgws0jrm86n0lnzb1WFTOcVkhEVDrti9vWO3YxJIbDosAmWdt3OMV5tHt2qbm= Gf +eGZlPXbj3ZuwQS5j8gl73c5bthTatTYZtB/JHTkvj5iUklM3VtL5ROzImSnW1JZU/iqhE3a92D= zz +mLWVSH7GertSboNVvxeJSZF9pazgtcdCSEoZhumnXoXUhqzJomtWSh9WpLwyuZaeeWyzWjr6sN= vU +BgXFjL36lXm0jZ3+M8s//VBIBu2xkgzaYSMyaL86e/N6Vrek1OYYm9OQ1F+bbkZYCI5iKbHBqt= /X +nGREpbenN+VQC2p1RHKxxTQOu2jGppJzimR71UNpVQ0Hx4LN4RcMRcNpbNNbmQz+tjlKq4RdOo= NT +rvppyYoImnbmphxmjaiQQ7XYzZjM3lRM89lTrcpUi42q3S9JValrRH6Gb7SrqKKQUPItCXaTXu= lW +yiy6Sa9bNfu21lR8a/u+Z7n+8d3n/21v23M82/+9v+xrmcbxW55jmf5u0usmvWratatbVqrFsi= q+ +76/n+/3etomvJ7797a93k97sGtZNa9Uqvt41vluq9Ww6lS3DWrVrzqLb5lqVb3ev3Ohr43Zd43= R9 +3/Ud1/h/cf/nL9u99y/HXb5dtRevZ7r7u8u3Tcc2/l+bxvs997vG5R7XtFt9e9grv/LXG/Xe7w= Kv +7Cq5XrnTd9zfuttzbXs/45+W/x3398Y7Pdtxf/tL97vf9fzv/+cZ73F/a/y+aZv2Nd0/7X3cX/= ye +b9nP8r/ve8Z93F2r3681Xcv1bNvWT6Tl+yba9J+JvbZ+Yl1fZZvGcdlNc5fu0tP3x+P717Ztx/= Wv +3TTZtm1vd+/j+dfu0t//vmf61/fvsT3Tck17+rZx267leJ7p+67xP9P+7v7Hf6bv2q1yvf3trh= XX +Fs6KNVulXrZpelqt4sTf6ynR034mTq84TvTX+5a9LbtHN+kty2LdpNg0KXabVW7hrFgmtGvbq+= L7 +3aQXzlrNOlnVpEnvWjWbZbVqncW3u8Z3C2fF8t5JWXSvbpTqprnL9999lnHc17Ydz/KLe1nG4z= pt +9jOOyzgd47K79Lfd6R7b8o3f/eMyfsezfLtpuLd9/WW8y/KPv3y7S/rXHb/tu9M+pmn7/XZ93/= KN +93/XsVz/d55vXJZl23d8jj9tv16mcU/b/dOfjn2t9npc7n3ufp7rO75x2+Md97Isx522XSuu17= tS +Ltr+9V3T/uNyv/Hbf7vb95dlj9s97q/tZxr/9sflLtv37zhez/Ic9/f28jx7e677x3FPx92dev= uN +13OXv/e3PN+z/92u6frbuP+913j86R/1t03b9cdx3K7lueO+2733+dNy93XvvW9xvcLgi7tVbt= bd +cs3Sou+nf5T+NV3/b9O+lmO6vl21d8bpu8u1t+sZr+PZfuX+5dv+vfa1HPv+XTflO7tsyre7Y7= B7 +tKZJqVdvmjSLLcNqp96tVvkG3zSp1ar43n2m73/bd23j9hx3qRlbmtL+1Om0vm15/lbiLFunRN= yK +z0RbnqvEqqfxG5fOwTHYTXqFTKesLOlWylxAamUtk6o5vfN3UgbfsixWu72yVteo2GxW8RVerX= W/ +b9m2/RQnWvt8E6W2dCbK1atMtGupdbbe1+AY7BpfE1ppdg27pWKZW62yOAa7Uq7WunWTWlWzzT= Ha +SQm7UC5XupUyq9kmDD+QB0NHSZ3GlZJNzSf0CQoKKgoFBfUEfTabkkq43JOOhkgAdfD1cAAhQg= gW +Ej19H5FJ5ZLJbDadzSaTuVQmkceb9kQhLCQCBIce4I278/MhiMSQERLRz/VtPCotLSGXlpSOxr= ue +PRHJSIhE0IefHfcG+LPJ0enhAEJECSIjYVLcvzzTdW3XNT3Lv8dJQiOiEkEgOPTo5Nj8blyeHw= 9A +QSWEioyCSEMisVgsFnuxWCwSiUOkoFGRUIkgoA4/PO4N0FdDM7NBRsb3s8HR4fnpACLEiBJCQ0= Ww +0dFR8OjICC4aEioxIgSIDj87Ojg2P9/MjA6PDwcPIEIEiRhBosT7Cr1vCRIjRASFAOGBgw+PDs= 4N +8FczM7NBRuYHvMFxd3h8fjp4+AACCCgEEBCIDx46/Pjw7Lg4N79fz9XZ6enx8fn54fDz4+PT07= Oj +4+Lc2AB9PqDNDQ5Ojqujo7Ojo6Pj5uDg3NgAfb4Zmpoa3+8HBNrY3Nzc4Nzc3NjY1NTQzPRmaG= hq +anw+3+8H/P18Pl9NDQ3NjAwNDU0NDQ3NTE9mg0wvd8EFF1pooYW8twIMMMCQQgopgAEDRowYMS= 64 +4MILL7zQ6/VMMMGEL1++jBkzJoUtW7YoUaIECxYsKaSQgg0bNu7u7kIIIYQtW7ZQoUKl1+tRoU= Kl +gw46yJIly5YtW0QQQYQdO3ZcuXKFAgooqFKlSgghhHB3dzc0NLRkyRINNNDAx8eHCRMmU6ZMqV= Kl +yt3dHR4enhQpUpLJpAYaaFCkSBE8PDwMMMBggw02uOCCC6rVKhIkSPLy8qZMmYIECRI8PDwLLL= Ag +Ly8vRYoUrusaMWLk7u5OSkoqR44cSZIkceLESQUVVMCCBYtgMNjr9Xo9BxxwIEmSJHBwcL1eL0= WK +FDp06Li7u2PChMmTJ08ooICCHDlyWFlZESFCJC8vDwoUKEiQIIEBA0aPHj2OHDkygAEMwIcPH2= 5u +bkKECKFChcqRI0dq1KhBR0fHgwePIkWKnDhxQoYMGT9+/CBChMiNGzd6vZ4OHToKUIACaNGixY= cP +HypUqIgRIwYPHjyCBAmCAweOFy9e5MiRw4cPHyWUUEKPHj3o6OhgwIABAQQQfPnyBQcOHC9evL= hx +44YKKqigQ4eOFClS2LZtw4aNOI57vR4Wi/XixcuNGzfm5ubExMRkWWZjY6urq6NBgwYXLlwccM= AB +ODg4ESJEsLGxsWDBoq6uLi0tTUxMDAYMGChQoDAajXR0dFasWGHBgsXa2lo2m6VChUqUKFFatG= gR +FxcnJiaGAQYYsGDBggEGGHh7e1OhQkVdXV1aWlovLi6urq6OAAQgABMmTJIkSRIXFwcHBzfBBB= Mc +OXKEjY3NiBEj+c7OzokTJ+jo6Ozs7Ojo6LLZbIgQIeTk5H78+MGDB48VK1aECBGi1+uhQIGirq= 7O +zs5ux44d2+3W6XRSqdQVK1bY2dlhsdher6dChQo7OzsZMmS4cOHi7Oys5+bmNjc39/b2ZsKECT= Q0 +tF6PBQsWcXFxvRMnTqxYsUKr1ero6JgwYYKOjg4FChS9Xm+BBRaoVqsqVKiwbVtOTs7Ozs6ECR= O9 +Xq93dnYmJydXV1fHggULMTGxoKAgFSpUxMXFBQUFbbfbubk5Ozu7FnR0dGlpab28x4IFCzs7ux= cv +XsiQIaNGjRo4cODYsWPHjx8/IoggAiNGjCBBggQPD69JkyZPnjyBAgWKFClSqlSpwgEHHIAAAg= hZ +smTRokVLly5dvHjxEiZMmDFjxqCAAgpfvnzp0qXLCCOMgAULlg8++ODKlSsZZJBBlChR8vLynD= hx +smTJkiRJkhw5cmTIkCFAgADhwYMHDhw4XLhwUVdXp0KFCgAAAAAnTpxggAEG4ODg3t7e3NzctF= rt +2tra2dkZFos1MzMrKys7OztLS0vLZrNarXa73aJAgUJOTm5ubq6urs6FCxcxYsSYMWMGDRo0bN= iw +kSNHjh07dhgxYoQIESJChAj58ePHjh07cuTIYcOGDRo0aMyYMePFixd2dnYsWLBQoUJFihQp4u= Li +4ODgFlhgAa1Wy8bGpqamhoaGZmZmdr1ey8rKzMzMsFjs2dkZGhqampra2tqaVqt1c3N7e3uDg4= Nj +gAEGGmigARMmTNw4cbndxr/8GqVbKROG3f72d37nt7/+tf3rX/m9+9vNuN7+4vjrvX/DXrn3ft= /x +fH+atnEcp+l4nv8rz3Yt03iff9z/TdNyPePyj/v75UpxvU1PKysVCwArs+g+uV7/CoNuFltmbT= Ja +07BONuXro2709bPHa1nuX23+eqPe7t8FXr/VKqWzXMXrP1OvtpXYaXtKxDs9Ez99vYl39Xrjt1= xF +oqB2ORnNjkgz3IyiWXuaWXHatJ2ISkksq982K1kp3WgxKxGrVitKjWTYDaI1q2yscKrqnUJOwo= 91 +u61sLqjc/FNrYMiZerWi+i20KtoeGzph1V5YMNVfEdXGfhPX8um76renrpWl0jYTlelWS8/clM= O1 +pC7ksItohHWDGZtKTthNGqP+7iWDLUGdtjpybqKVWMo3LzJpky25fCqXnrhNFVvdwv7RKLyVSB= 6f +n8UsXiQfjVTBolG1L8FuUhs0yTwC42r6d5FwraqckZLC/28yaFSpakmWq7OHiUqnsCeadS0J1o= Rd +oSkypuRT38KTcvIeVpdOpaipNZuYtPTIpH5lBp1IQqfVFdrvd9RvOr1itN+rRmRWI9GQU9D5Bi= cx +h28y01O31WI2WnrldExii9NvhN2q0sh3rVD0mGRKiVW39our6fuyqhNzaQ2GoZRtTzPdlYVyej= Wz +qKwiqKtU2ZtHooK1zSKr2Uo0dAW7y6nj9koL62zWMqOq+ltDR2yRa7aDSF5LpK+jryyjpiSY2Z= CW +UWwITb7HfBYUTfakxlBTLa1IkFRQQQUhQoRo0qRJlChRnjx5okSJkt4FF1yQQQYZUKFCxYoVK1= Om +TLHAAgucOHHSmzJlihQpUvLy8nq93pUrV6pUqRIlShQLLLCAAw44+OCDD6hQoeLEiRMQQAABCx= Ys +V65csWLFygYbbNDDggVLlixZRhhhBBBAAKGDDjrwwAMPsGDBUkIJJYwZM4YLFy4mmGDCCiusUE= IJ +JXjx4sUABjDACSecYMWKFQQgAAFgwID58uULCiig0KVLly1btmjRogUGGGAQI0YMGDBgUEABhR= de +eOHu7o4FFlgIEyaMFy9eer1emDBhTjjhBDBgwNBAQwsttBAmTBgFKEABK6ywggsuuA=3D=3D + + + EEMMMYgRI8aW6/u+6Rm/a3/jOO5jvM/vt2vZd/ym7f/6P8+yjdvRqBpeS680FbfW9xQnfutVS= pzr +6Uy8+n8l3r/GcVrqOyyU5bdJ1eja1Eed2KrKo5lZ0/mxQSRnmNPohqQWp5w87HLVSkp5yksI6W= 9p +sWXrobfrkTxV5RTtV01JqPeCYl772BPqSCZCI2Orp1VtbZ9Rrajea8gJq3YWOQk/tf9rf0KyYn= 6s +Gc0041VW33G2JeTwyapcU3pleeYRdpnG8CuzSnhkGhYl4bQmt2MW00y0Yn77rm1q0KZ66rB7/7= Lo +0w+daNaeFN1a+w27TfUU2m0nKiYopqP/xKTG/Ef+Gi/dRdMkGbR3KYVXyrhJB5dKtx9cwq612S= RE +fzOmK5NuXs3dCG9aOq+eXmFPtK/osBkT2VHKoyfT711I2jNcOCONObG3Z6OdoEjkcIn5/M9O9m= Sk +YyprfyIq+g67RTURtfllY1lxNKG4a5lH8dpSFmppyoYWjUZlbNRY1VRI1RbldFQFu8NbWmS1NL= +5 +XUWPrtqwxIiMtFbbNqrINTQbEruMVkskr6gtLRPY2FXXUlh2qc0oNjR2mkxJ6UtJo4RPUNMxWK= xZ +zaodl9Yg11XyGlzaWlqzTkXO6tiYFEqNokZJSWFXSQpFkw238j2WHXpbChsrNiXBouSvoy+j/S= R2 +DZnYIldbV9XfEsMa0mJFuY7bq6Us0dDVUFs9qmoTfiSqMSLUVSrq7bToErIrCxVjKduetlqhC/= Ys +GqXK/NJRbAl6lhQmFnZMOkk9kUNYajRtktVSSnnqy2sLSkmUDUJda9I//dAqi3q0pVVlRaKd1i= TF +VvVWS6vKhLZgthKKBrWtqdotKOXQFuuYfHotmRlhd2zKiKylTkl1GtkWlLItPvtibp553KrhRb= Lc +pSVa+aIUu7zq2qqVdtRX2JMIWU91I6GT1Qpluq0ZXZnBbey0FPoa+7d/PvUhGFfTX/JrZkVbaV= Tt +X0K8SbZezYzI3oR1ZTbDgncdUynbkllT0W0No0kZk23UqytzravD7lGVrJSMVkHLmrZPbr1fcT= m4 +XBqn0N5EkoNLNq+qE3MKrTom66cQyUksshUdsZqwksMo5xTak7xq5FDOwhYxp0a2p386n0/9W5= +i +imqxUbXDLtZW6C6KDk2h/Sk730XzVI1s+WkisZmGM7GUbUzDpeZV+YWWiIqYzeGTlApbjL2eyC= FR +OwbtYDOOM4WyUH/ftf3xuMZlGf/vPffvZ1/X///747csy/F8p0Wjdv/f995/7O3vqr337W3vaR= zH +vY99TfXWqtQmylTpTbRK6ZlIz/RNrOkq9Z5Wu1Smp1MZn0qrt5VI/34T55o6E6u09BPlW3pXPV= Uu +Enuq5rKUfBzgR4lplpwLWxWUGPIIYDCcmXFDIc/zFmTUbKCp+UEjgYY8zylgAp5TQ0NT4/uBYA= GD +khE/Xw1ND7aToQI1RKDrA/BXczPEcd/IGIdUoIYFinBsfj4bnB3lnZYOjs1vJuokxyHPzMiACJ= vi +xoFGbAMmzZ2cDUYmRnDBARE6alo84JprhIFhgqKfODE5mLWbnA9NJS9AgIP4J+cGR8eGIUMMdE= M6 +ODa+GpmX7MoExDwBuTfAv0PeudFJYoBLAq4ldG5sdHiUd06ePK7NUg0VZJA7kumpyutgTKZGCQ= wR +8OF3NvSQXTkAXI8MD/UKDRTIO/LI6PisbWHBho+O69NACjVogX6QGyMDEw87OTY/md4QDBkW8B= U0 +s2GGw9/RABpCkH1mZP6O3ETwd+MGRZfkXaaa7nIbtgxctkGYtCCdG6BNDg9VnpInT44NsMYGZ6= fL +kYCAOqEdHBuyK1XAetwb4E5yh5gYIhDu6PSskZBz0fbo3PRYEYABEJAi73AIwJgWYHDYwQHKyM= yI +KBMBAhM4QNKDe/OroZmRoSmSMYMDjBzRbJDpIcmtQIEaZgAb0dvg8sg8LljicW1+NTMbNhx5zE= AD +nFGPZ4lEBC0e96b3s8nZkSIABWoQgN/JsfnRzGzYgAXlS1sPDU3N7yaHZ+wKHpInRwaIoyMiK8= IK +MT7o4ABlNvSskcABVY9786vp4ewI7cBIQGIHp0fjA97o/KBQ4YTqj84N0EezwWeTs4MLWcALVY= I7 +OTa+GhgzkMAAj3vzw9HxucpwoMYNCHb4CDKkyJE7JBMoUYKHp0TJBEjujhQZEsTHDghu1HBAjs= 1H +Bwfoo6n52eTw/IAYMRSMZRy5hEaprrS6vMDCwsTExMTGxMTExMLCwLy6tK6ootAlEpfj4NAIED= 88 +OTa/mt6Ny9MBiASRMJ5x5BIKNWWFpcXV5eX15eXVxaWFZTUF9Vwi8RmoA4978+sJYxlHNjmfoq= aq +rrKytLS2tLSysq6qpqKenEokLsdCIhIhanodQpAgChK/rZRcOp+iUVNUVVZVVFNR0SfnMmm0Pz= FI +RCJEBx/wxu3pAEQidnzPclSNxq13x/vV0zSVOEvrKbG+1jOR9rRNvKnfev/ppzoRCb/W+UXbVi= oi +bW9pkZofdqFFMNSHHQmTfFfWi7bVrF1Lue0Ly1aT0WfNb5UyS/JjzNnJl1E9lzIWDUr63bZGLS= 2N +glLZX1psV/XXsQkJuzLxi/llpCTV232K6qnfw2jwCruwC7uwC7uwC7uwC7tI3opE5UVmJBvn51= On +Yfqpx0u2JL/8ik69nMVikrGw+8S2hBwy3bKu0GaX1rU8y/anaY/33unYpmX6y55KV2vr7D+x1x= 0n +0jI9E/FvX4n2/a323GeXmuYu60/jsvc/rvHvptnyLP+O47Ov4xn/7vKd5d9tWY5tWX7njv+5x3= Xa +K/v7y977uZ7neJZld9nxGaftGK9re77lGcd/7eMbx7v/tY/7/emP/5qeY39/V63G/59t+pa7/e= ke +y/e3ZS/Pt91r3Hd89nF/5ZruH6dx+stfxuu4vzVN4x6vbbqmb1yu4/7S3uOz7e2axvFO13F/7f= vX +vd/9nue5ezstGvUyPc9etnGc9vHvsqt2y7L117Q9X6f+rhJrG8eJ1Wp1JuKzn4lWvN9U3JbWtd= z/ +bJ3KVXtKrOk/JdK3dSZW538TqzcurdZTq8zv5/NtAAKBwJ+v5ge0ucHJcV0dnZ0dnp0dHR3Xzf= n5 +fkAbnBydHZ4en58fDhw69PDs6OTg2AB/NTQyOe5Ozw+HDh5AAAGFCAoBBATCQwcOPz07bs4N8O= dz +dXh8OnwACiGCBIn3FRIaEhJ6XxIkRIQA+tDBh0cnB2iTo+Pz4wEoaMQ7RAQbHQWFQqEQSSgUCo= NH +RjDR0DsiCMjDT49Ojg3QR4Pj8vx8ABJRYgg+QhoS42LvvvdiTBwiHcFDJUQAefjhcXGAPp8OIE= i8 +REdIxOKXZ9q+7xu/79umZ/kXiUhHRK8IEB18PgSVIAoixZ628aPSEpKJiYmJiQm5pHTEbdrHSE= dE +JYI+1IAQIQQj9V/jS0zKJbPpdD6dziZzqWRawusfI8FCIkD4iI6SvI0vKZdO6BNUNCpKKioqCv= UE +dS6VSzjtk46IZGT+vZRkPp+ipKiqrK6sqqikop6ezKTS/UPIMJ9PUVRWWFpaW1tcW1taWlhWVF= FP +zyYkPgMFnaJTVllbXF5fX2BhYGBgYGBfX15cW1lWU1Fo8AfECKEjonwjl9Coqqutri8wMbGxsb= Ex +MrCvrq2rqijoEnnLxCOhESB+fDwEvUZJ3l5qekapsra8wMTGyMikZGRjYmBeW1hU0WfTku2TjN= 4g +Dz46NzlJJxQV1pZXmBiZdEqlUqtUKnUqJRML89rCooJyJnN8PgQJGSX9G8l0krLS8qpWq1WwLi= 0r +KScm8v5JRkJBH3x2eDgAkSASFumj8hmlyuICEyObUqlVa5VKnZKJfXFlUUWfyiNdFBKRAOLA49= 78 +bFTZwMqVDjwAIQQsWQwwgpYtJHDh0qVLFy4kkLBFywgGyIIlBBA86OCKlQ2WYHGwE5jBziYEFA= nk +eRHQh0NVQgVynJ9OjwR00fYcpdj44sBs8HUTB5kABJ5UAclEyHMnUEQrHJCAHcemBXlu5Aj01Q= BZ +F5Dnee4lTviLg+R5jiHQ5zmGAjR0MBbkC6KT4ZcT7AACef5CkiaenDMwYkzkiEACQwoOEIFWHe= R5 +rgUL/IHBQp5FK+JXs4SX53mek/1yAdbOkEae5zkVliJGGx/NhtdNAg7YQf9qaDbUUHAMgR6yZq= iB +AizEEZWIwAF5LoNdEND327G5SCDPH/DBGIdfzpwKeZ7nOEBhngPyPFdAEijQZzZCnud5PoKZTY= kd +L5wwQ/5NYdD1IW4FbdFxCAGcZHjGvORhefgBhXRFcCBOMksexNbx0QRZ83wC+Q2kH9GUCMSwDQ= L2 +NFWoIc8r0ELcze/GhwLyPAzczc9HswFYX5lAnkPAgynQV4PiS57nBiizEUrwgCROvxqpB3me5x= ps +/Xw0vhEtXpAx+2p8TgryPG/i9NV0OFshz3MR1ohoOgR5nguhaWZmcpxMqGCKgwgG8jzPaRBt8A= lF +oGEGH0WbnC0EyPXIyMjY4MWQ57mYAPDMyMgwFSDPczBtMizkWMiITWi44pWD6gYD0tHRrVixQo= UK +FXJycihQoIiLi5MhQ8YDDzxgw4YNCCCAoEePHkGCBCFChMiVK1c88MADKFCgOHHihAIKKMDDwy= NC +hIgOHTpmzJgBAwaMFi1anDhxooEGGjgRFxeHAgUKOTm5ubk5OTm5Xq/Xi+O45+TkBAcH1+v1ei= tW +rOj16OjoYMCAYXfkyJHe3Nzc3NxcVlZWjx49gAABUldXlyJFirq6uiBBggwZMmQ4HBIhQkQCCS= So +q6tr0aLFkydP8vLykkkoUKBEiRLFzs5OihQpGWSQgQsXLmbMmKGBBhq8ePGirq6uRYsWM2bM6L= Vo +0UKGDBkyZMiIESMGDRo0tmzZ0qVLlxo1asSIEaNFixYuXLh44IEHDnCAA7x48WJubu56vb548S= KF +FFIYM2YMDRo0esPhEAcOHDx48Lhx40aNGjU+fPgwY8aMBx54oKdDhw4gQIAMGTJEAAIQABAgQC= CA +AIIbN24cOXIkgggi+PHjR44cOTjggIMgQYL06NHDhg0bRYoUSZIkSZUqVYwYMSJEiJAePXoQIU= JE +iBAhSJAgWbJkCRIkSIoUKRIkSJA4jo0YMbJkyRInTpzk5eVVUEEFTZo0wcPDk0ACCXz48PH19d= Xr +BQkSBA8P7+7uzocPHz0gQIA4ceKkSZMmEkggAQ4cOHo9JUqU5OXlMWHCBEmHkaijCFGsBIEIQW= MQ +EaIhTZM2YxaAMRgkHA9L1DCoDDypAxNAQcXFgbE4GA6DwuGQaBwGwzAURGEMBjEMxEAQxWAUCD= ro +YEprgy50O+K79eSILVg5kStGolQwKPL281OEM2BnA3Jl7sT9gW0FgdUhSjk5BkutA2uhe8wb8F= 7X +jmlwigndtNBJlu+2nwO9aGChq457aaHjHetjoasc9ttC1zvra6E7dRQ6NgvdsXy08Q=3D=3D + + + PQrdJWGh455ao+Sa6Nt2AhMjdCAh86C76Es8W7dKN6BxdUZuj9lZznh2XTuUHs72s7KC2T2r3= l5i +6vE9OZ7VOTttUmc6AUUusYnkmTuDO+HKdEI2XC7zt4l+i7SwnvayFK7OKgXgUMyxPuIMiUiLab= 4V +tYoohEDlipgTRSSxXBEnN7liXuG87ZJI8FIWRGEOYQUtOODNclb7FRrC8gx2niPSk+yuRvZq+c= aL +ubhG0bKpEqDpI9CpkyLqTiLUkkXHneXZkE2zzZzBCXohX1/TVXBVsmDnOLztQfKE0xVM/q0Mcg= YJ +nHUkZ70v083K+/zSIlntSo6wYiNZnUYcmL9DEU1lqVHEH8QraXCBkQcw4i0FQXzpGELsiC+dFH= x1 +OxkLOZiKSS88UWWfJ/ocL2hQQgeIFzTvGyjq8AV9YlBc6bCgC8ove/mdLVHDLwHiplntlEDcJC= IT +tmXumAtWxAJndPkD6o45qZW5LGaCLIKJwByVwXDwVJbbY8YEmqOyJAGLO3EWcrkX4CMkZWI5vf= VV +rd4DW+C6F+Srd7F6Q4BaR3C0H+APC9t6dy3TdNglDXZftORfaqz9+P4phKJNLu55LiFMeC3dEM= pW +gVE0quJeaKhClnGPwVGmC/Hol2eagMnedDnDl+TLItvG/ZUbbmLDs6QIb9P1ssR/wGKKSo1Go7= ZE +dbvrK8Svw0LgaC8GokTFXYGaQEF2ZKRMG4h1qBfwSUlwi4kLhCDMWQRBHeqKVU4cIpjctmdHIr= I9 +WiyFmoBz+Rr1davAnh3rhytnKwLxAQeWwxm77Uxk7S7uNsa3gfioEJ6dO/n6cq16lWzPzCrknu= r8 +nhV1ovZWghnaAM3DYo/pQIVL6VDgB+HZeChfzGTP8ikeF0n9MPhjVJeInT508OAfARPSOjzLnF= KV +juH0gWB7zpHLnEAywsou8ICFpGZvWSsQP/miE8+dmWMWYWKKlAQ6yjj03vOnjvrnkngJnVh6Iz= rd +ei5rmF/zV3qTd5EOIeVU5R+yrIIzoZCZPpSnDjBxUDnBFRX5JElH+upiFzYJZ1FpUna0TDn/is= Xs +7DexgnZgLahnQiPIngFOGszOjYJ74Om/XEgT4Jx4y3YsUHMRns8box3aFHM6cY+sIuQ4gR7thE= Ba ++SS8v53GYRETTcZPM23rv2GRrWjs6nBodDfzU8qq3kxOOCsvx0TG1UqWXKQ5as98XDR/Z1Ke+M= KO +WK7j8mbjiDQux8FB4LAzpUONjbpli413DJtD602JXUm75Zk91n1v2m1B11LWm1pwYavisqYIoF= +m +kYBBREOjDDTv1soJgoqjVIVIpEOnTCHd+bB98DthVV+Qnh+FUerzwzLifUIqL7VPoeat9impvF= Qf +pcorWs8PmUK682H74HfCqr5RdD5IwlhcmGpENY5CFSAk7Z7Zx8CEA7VwydPqhEo4SRYU7RZFSy= kr +vA7C4w7odsE7cR+qYn5d5VQKbbm2iJNPTc60ui9S65iJUfTLhTd41aoHQivOWe6E7DOK9sEzkb= NO +8e3F440LJPVDCCCEcXa6DAJ1MZmXQaU9QT2lNC6dfsnBO7lRBhVatThr0lAfU/9lGQHJF63IsL= lJ +u/b5EjSn4mIEkSUJG0L7pVLAGLY0w8EnycVru4CnLsZssqgfTNlXwU2XX/ru6YQFykV5khNnoT= ud +g8yfcaB9GHwFPYBXT7jgRyihXr4q1RyX4AYqy3XRdL5iKsZAmU28MYkkL/rrLKFMmrVrAuOOjX= UW +Tgh6qFLeF4baL3UIAEVliE0dE/ZE6MklPYw8/t8mpQkgGTPKRgvrtM2fi0hMpBg1OLMzGt0rDK= 6C +igSucAhBLPJ1EqokYmrBvHW/E8mmQak5yLxOWWKCAiWBEconfAQJSlBmzn+ZkzID1Hvye6pOCQ= +o +2ayJzM/BB6BA0K0670GvoZrQHoYOVoCCIOGKB5quXNM5pFDW03IN0CIQWeqg2vcZQ3ayJt/GTQ= SP +39Rbn+3kOFOUAEBLVaan226SHyKINUJ1s7o4xerrOJvRNVeiEQF3FlQs2A07ib2R6WUvhv4eCq= aT +9xHR0T6UO93kxbxJ2vESaktyNJdAtfIhyL+hVoITfETw95JuqPG9kceHkOKawr8RFAZfnTXXTe= qt +U+ExjkiqYqCa/ymdK2F54XJTRpAAzE8Hauggu03APrZjOBw9VFA+IoY6T/WdEh+IffRNQ0/0pt= SH +IjuiMBoWqCfluNEI4VGOiG6oBcKKwAFBCTFDw6X6lWow0c9nFOpiImI9HXVghvZ8op5DQzUZIa= 5r +clvj4kdICLWP+MIJSpVVx7U7KkpO6eRuOhpy/OChdHLqqi6OicX2sFMyTRH2Bbx8kvm57J3yu0= fJ +UOqJ9zoMaov90CnS2AwktrNm1m97Ugk1qf6TZ1AqbNlBiWjy1CjRjdF2p74XfGqXXYR6PB8y0s= /D +gdt8qlMfvEFl0/DmCUelvhNQ+xI6HEDlY8noaAKKulxc1V5XGPyndi3/V3BfMZSjbNi5EUUCBr= +l +n16hHKCPo2JIw1HkkGLdeDw73QM1gmvQ/xhB9QCdCveqQb0M9n20r3548dWw222XKiWPqKTCAY= wA +xv1aq3jRlOjpXdIKIOpicagrQZ/LosuTgCkWuIDiQdlnwQnrLXC9ghVbKdm9mPj5P38YJwe+wf= ni +DSavgFcWOFtN4mGxUYKr6f5iH6+zDEGfqqO2JwOF214agOFcH1dUeQIUvNwK2Cy8N9Z+52CF7p= bT +3AJjapmPapNyQ0tUdHHDRd6bpU3ZMGg3WTSf3XNLf/DlFScUZ2BfdAR0GXeqyTge8I9p+coke7= Nd +geeNZ83mLii1OY7TOXeb/G6EQiy4g/9PUtgSnOzibrXU6L7SlqhwgrvRbLQvCw4CiRhsySpqdP= 4X ++WTwuhELTvqDXWFiLOCUkO8A3a1CDoCzmHCtLoXKlo+hB7Vh1zLuPKh8KkrIcUBfkU+S8+DDaH= wD +B25ZfMhZQoQP86Zd1vqyVzjh2oAqKQLVrzpgAxea//kq4esAqzRchY2fx2sLKTZu8Z25yu5kMw= n+ +/bkosRTPWa4qYoJv4WLubXs2GCsq275qJ9gslzKzIJZWYWX9ZpuajeKMZ2AXEG3zkyj00GpLwZ= Dc +n1ivjfIJBa+c8Wpi5N1js1muyjq1qNlfQNo3Plb/X9Sroe42Hr3cKrqnFIYpls+MoUKe4Ir4T5= H/ +xmCDJRLIz2VlDEYIG6clIAwkkP1/Ydo4gCOUHZtilrK2tQhufMJ3AbvimUAKxT2b54R5VhjXFw= UG +4R9FQHPvwr+WHsLW6vrwvyhkG6vsDl8Wz/lIvpMjHNwnEL3lT3CCNRyEBNnOj+xjCmqE7Qtd30= yo +I74Uqwk9gX15ChhrkU9g9LIrRq2Fp0uJD2jt7IajrwDse8kA4hmRo+c+ngjs/UIuZXFKm0pTAE= bv +v4iXt7yu6A5vig+XApd6ly2Bb2hQIk0Y5QGVWGoYFwxV07NIAPFGWT1opCBxIdavizDZUexern= VC +PCvoTvkYZqfSim6xyd8qbtEU8iXugYcZMFEvqPGJlHLVfAUfyUbi/aOVz36U89ZsK9hx+zFy33= 61 +fuYTSaduEt8BhxCGAngXO/3NERh9xVkoiIE99qZCoKTHXzVhNnOzHPENlsyDytDQSbsu4Uc80u= DJ +4Q/EwmJx+MlQIN6ZDrAvgS2ghgtNaVCVW/OS75LQRVdDWNq/d3rCHyxizFCrZOM8o1lCEbATXm= c+ +pDAn3OFC/JkBL3k21rQfV2YiV9z9L3fTQj5ldMS+F+GFWxRdZCFhGfZBhQTvSCI+AT7P2xZtXM= xc ++oXLcYlAn0ETTQOtOBmbiD7PIDftibmonMXZkXqtlvjjg07LO4aDYA3G6a9Nkue3F6Vyrb26Xs= g4 +R3o4fjoZyrIwdDDQ0kkMNzwKnDpQAaFwEYCn/W4YfQiaalFLTu+N0HQqwK9pCE7U15JHNN1Guo= Fr +7P4M35IAJFW/qdGj4mdlTX+d53woscbukbk4JBgUliEyHNmTyww2GUGFzcqXTrERWvZCCZD/ub= QE +jbHQrnenAAbxVVfupJLMfTUEfdXzurgDqdpnfGktQKrSwD8+NHazLU25szRiosWzDToBlS6Nwl= 7I +ZjweDEFWfi5l3OaaOKSgPl4uWWpNmHSegZ0y6gw5xvFwjyJEhZoJaAQ/+c2cnq30PVoKSB32Na= rF +Q/g8V3FPcp1QjY8szwGTfoOkIQtyRQ40G3WKv5uFab0dPKUb6gs0CqLk1rF4IMiZxN1LvBkBCL= X5 ++Zq+NpcHtYqQ70PnfCFdZiSBt0xcIcmUc1e5fz9j4g1mCPXrYXF46ch7BonEkx5aN5xs0EHQzq= YM +irEPTz/ODqoYN/cwp5m9Eib9JbBvbzEomg/qcnk33z+lv8NTEYCM9mk3G01JEmd78dAhwOYOh4= Du +EESbFRL0rkaeNKSenJouH2+uVDMcdBRqEQr2iIiifdkvPa7f4HGxw1fZaWDMouLUELI/Y4MmIe= UI +e2MKSseg0VGD+gkD2ysygK5SoewAwo8w3fP3iOfmCBvgR+nCTfGgpVPjMdSGyW4mFZKxyY+Acb= bg +z2M1WlCFt+ypnBxcBSU3KHFC6zJxqdfTn0FFokoNnncMEqrFe0KJKo3pccnplelAyWIxdPIR6l= WW +mLpgbAP1cz3dGije22swlzqdqQUH/loEgvVYRakbKE/6WPJHOYul3Dj5aU9TvFlNmdJfITsmn/= ps +IA7KN9MUmEid+7yw6ue39oFU6AHKaYF6HIwJlgY7KJHVQIolSHPtDvXAGp8/ti8qzFSUxjPAYn= q0 +QG1UF9VAUL33HZ3UIVmg/AsFpSDLD60Dl9LaUeQ/S8qe8hmo5AJKp1NxpNddhUn9B6pbXRS+DZ= iF +Q4TC39N2aJIngmK/4bcPVLd0vstyevpCMuyHzg1/r0xOS2rRhaankJuJICCTQB9CEWqKZv6YBv= 8D +BWUqKEVQ6J96T7JRgjqrEAVkYFLP2KTrnmpqyiasdT45MZa0pkdkCw58vwWk9zzsEzNRy/Xm1e= pH +3H+QKwY++pArhi56UODBkmaXuwQOKkdRwoKbKFKCB5WjkGDFKRIpwUPHxfZgeTcQMxBbLoPCwE= EH +yJZg88aJa8CCiwD7gOU9R71vkhUF14OVUzLlMnMNvn6kS21A+DPuborILyq2BLW9yOtT/pJ/++= To +yxhyYbmT8O26k1JE25z2TmZChGQrtIdWTIZnHgqRblH5ZpQ5UtcrLSdqJbZdzwESKw5TrsDnJs= jb +BSydj3/DB0ykqn7BtpMIuyhCetFNc4Jntn4KVKAFYWA65uOCX6acbMsAnzwBHUX9cc454PSP1h= w4 +0ayUiSQXSHKiBp8r/W6QBqtBo5UsWr12B+h0aSFRGKHa/z9woclQojBdW9l32QnwPadk6HTL8T= 5a +2pPSk3p1AcSKz0PS/jFzZ+Z0/L/mC9JvRxilL3gvjOJEXcVNM3offcgQ8Io7/4Z1CA=3D=3D + + + ICsFrK3h94XZ+TxqNOIN0kmx8O46BdDFxqGhjdnu3oMroOYL0nHlyGctFr6PZS7Dr7shhnWtQ= q6O +BQPkIbVK7PjFyczyCZyi2fKBXUkNN5+0xj2WnCsskekm+WF0E7OIkTV41rnN8sBttPwALIUgAn= Lz +XArJmgaRzMdLAwcZNpxy/1AoF6uNlcJOwfSebB0h84CI63JERTJI0r+y2D4vc467mK/EMmQetE= mb +5VDcIq9kiGXvnv1Lcm2TQiRDM0k91y04G0uHAxjbsYTyOycaN26nsmysrgNzgcFwHbT0NYtgep= Wi +Hg7qMpI+R+xl0SbXqaoATbqs3epdqH26vMBkNAGKSwFQUBAYJrEHwakNZCEadWG+12RPWdyagI= TM +qatrdsPFhUQwWRBXuf4bTBT88NTDD6lxmrZ6V6OqGFgcig63VknaKaWUUkIklHSW0QoIo6pGa5= oE +LAWgBBIFTE1RU1ZYWVq+eDwmk8liXysLy2oqqolp6uTt41AIaAmHJAkFS/Ca5Ont8UXh29PLa4= K3 +hIIkRcSOM0MSJCDtfCnE8UCYDT6XLiiGYjJgAIqAiwgmgGaCVis4cCL8P1CJhAUV9sgCqKInno= lJ +wtHl/38TeDiJnczAFK1t8cDFEivkt6PKmLX8P5QQRb2GzpaD//8n+AYZlSDK2ORQVPh/BhgAqs= PD +NYJPjI+QBRgBt1KuAGDGBk4EKWQ7zSI/lC4BcPD/FHiRciykMCRKxufTzsTICE0wgIQZTpkrAn= 46 +5wzMVwl9A0jC5/7/LSkDs+P0QQssOCF3GErRpUuKoaBtQQoL+HHVuTmDIICbGQSAnPD/PwhuNj= CD +1QXnGZieGCIEQCgG5oALLy9UIv+v59so0MH/K9HSuXDb+P//l4Aro4XB/9eozsRkiBmqrfD/Xe= aU +YmCqSP4/TuewxeVEUgyyrgVRBkYHK0IDzEEbGjjh/01Q84nJgOECMGkvhf8EIk82vwSu/H8HZT= Av +QjxOmNG/HODd+38LyAdg6GkhghQSQwxTIN0LNGUd/Er8ngsvL8m36svLy0uGqSj///87qDMvLw= go +oL8omfy/iyMd8AoopDAS0oHmY9Rke/DggQQJEi5cuIgRI8aMGTNs2LCBAwcOOzu7Hz9+3N3dES= FC +xIgRI0yYMKmrq6Ojo1OhQkWKFCnQ0NBKlCiBhoY2NjaG43hQUBABCEAAFChQtLW1tWjRgo2Nzc= 3N +bW1tLS0tbW5u7oEHHqirqxsaGhIhQsSOHTt69OjR1NTkw4cPr9fLxsYWIkSItrY2JUqUsLGxtb= W1 +MWHC5MSJEyVKlGhra2NjY1tbW2vRogUMGDCoUKFSpUqV3+/n5uZmxYqVDjrooEWLFr+fChUqbN= iw +gQULFhgwYLhw4eLt7c2GDRtwcHAwYMB48eJFjBgxGmigAQYYYMD3/RcvXtSoUQMECBB8fHw0aN= Bw +c3MzYcJEUFCQChUq5OTk6OjonDhxUoACFGDFihU4jtPR0dXV1eXIkaOurs6GDRtvb2+/3++nQ4= cO +Ozu7ESNG/OLi4nbs2AEECBAcOHAECRKkrq4OBw4cN27c8OHDx5AhQ3bs2EFHRydEiJDf73d3d1= ek +SBEePHjU1dXZ2dlJIIEERIgQAQIECB0d3d3dHRIkSCKIIAIIfj9+/DBixMiSJUuOHDlyd3eHAw= cO +IUKE4OHhOXHixIgRI0OGDJGTk8PDw8vLy2PChIkTJ07w8PCSJElSpEiR34+Pj09PT++CCy7AAA= MM +9PT0NNBAg729vSdPnvDx8VGhQmXKlClQoEDJkiVLAhKQgA022KBKlSoYYIBBXl5elixZrFixcu= XK +FRRQQEEDDTSQIkVKlixZfr/fBx98sGXLlr4uXbpgwYIFBBBA0KJFC57jdV3bds/jWq15zPdin9= 9r +vg4r6bLN97Q+Huc0Xt6VdH/vYV7Z41vhpSknqihurZtR/MiKaOevov3xHgbHhl3rfaV7Ge8wV8= p6 +f1Hr4z3uEnV3oq8VaUttca0bqzSm3lZItfXmKppS7lJUREe4lAgptj9UUaHDIN97qfdtvIpt/j= i1 +wtZK/UM3WTUMDoPD4DAYHAabYVXSG+s1zdbOIrLvPQwOg2C+rA+Dw2CtXcLWz2EwH3bzHkfyPd= 7X +e873yrzHkUoljuvKvtdxpM7jPL4r67BYSa7DYtq2lWHaJ+85TfaVZbq3bZtc73h4jOtjfkwW1z= ht +9+Iwrft3Tuu+3dPhPQ+L8V75B1bQD1pL7pnMldRyMbv7viOR1OOS0l1Xo2RlT2T6MJjlFNOpzk= hF +qegZu4TqfmmvU7yrqYrOlp3CmEjitpgMC6P4MKMi7tWLP0tdgfX61JfV9qYaBotT5CQr/jo1Xl= lx +L9GLFX06v1/5eQkekuHKLKVQ3BTGll2zvlVWmEn85S2TkodP3LNXyTr2ucJMYi4SNutDhWO6Fr= KY +K7PInOcl2I9+oVhbJS/ROwxCo6bGK+RUsq4i87c3FdloqU89eU2RcaFFwiKurQwLo8iYTUYocZ= 8t +O0Vp8a4mKBRZWNb+Rs/Yog9dYUvLD0/t0Xkbvblgdz0Mio98JyOWqluvyHVx/OWjVGvZ0e4ykm= KS +HiHLuFEp0/O+0qlWK6kuqlp5lvJeqcNg0XN/gnaNbaNcVeWoqNToVjoeNcNJahV4KhU1U8PApF= rD +YDVp+zyKjSUpo+YnsJvKS5epR2Pvldp1hXV+HrFMRauXeYY+jZTKU+tXth5T76Y1ySk5DB6fpk= s2 +tcpKz4motG6oMb8r2c2nRGvSVV+mevDCMvNQ4OKXdCza23V5Nx6r5qeza8pF3ZuMRDAvKZUwp1= qb +RPUzHwZvvyoVFdW97j4a3nZz4RTbFT0uaUkxSZu2S6z0zGebzuf29gB10uqK4k/4eIh7MY2eRz= Ax +5/PIU4+7NIzUJMbvX1B+NYn0BVuHQeGU9Aw10rd37QW1odRvlnmNFoUhw6SU8OaXeyZSXp2yRF= xp +5/auI2s+x/U8t5V9jdu7jrT3vLz35fKe+2O8t+n65ns6bPc5Xe/1TfN6Hibfeq6DBae2ze+7jr= Tr +XMnXup7bfX7zN7Ku8yDYne/Keud3pLLHg1Ow4HSv833X9frG7xuZK/Ecr3He1pG6EsdtG8kr8X= 1X +9j1fI/c6V9a2v+dhvEzOxbSS78N0vvc57eP1Tfs57o/J4vJt7+Owkh/j4b2m+zpX0mLcz+l9XN= Zp +8q7E/RzXXy4ccEAMDIYXDBheMtDU3NxgAPLw8PAAZWJgbHBydnh6fDb8/AD54NjY3ODs9Pj8cA= gK +4vDj07ODc3MAsMZmh0fDTxACQ0XCIyKxaCQeCYuGEAj60cCTY1MDtMnh2QDUYcjoqGg01AHIhy= fH +hmYmpuZmR8MPAkNC4pGub1zfeaWy53cdv2v6SBQOdfjRsHNTA4zh2RA0NCwek7euXDKdz6eSEv= T5 +dDKXSv1OHovCoaANPDhBYM9Ph6Ijusb3pRMKdS53PHk8Kurw0wMkJCzSN798RqnW69VKjT6X+0= 0X +hUJALxo4CAmNSbxXilaZsk1P223U9qkpy1SNOnucgwadFw1AVaasExS3ampKigvllGWaAmnIsa= GR +gRESGpP6UomKbYLiTlFZXXm9XyuqKS5U05WqtNSTRqHQT09OkOenQ1ERmS+VqNenKCkqK+8XDN= b6 +eq2opKKcrlSlZY4sFnX44cHxCSIi0rfySb02RXWrrr7gLK1wFvh7VdXdNtFEoiAfY703pUvabb= fK ++83SCvvjrK+3qrvVLkmbe20cCgH5BBURabyHVrNQ3Kqrb1bYF4/H47EfzvpeUXGhslVoj9PEoi= Af +oeHR5p3TYm8zbMjhyEFnAB11BzjAAep0GIDOARxyNma8ublg0VZCbOcFqWkrRWXlxfp+s7xWVF= Lb +qxYqqktVZXV1RdWNgtIy5Uul6VK2CSpKqtudoup2paKgmrJLUqVl/kNC4kpnlLqE1To9QW2dtN= gl +atSpxJFIQiEOGuy9d0Kn1aUrNpvVYq9L1SnU2e+2Bh0bmhwj8t775hMqtVKpUyn02ez3G4mUY0= Mj +48NByIhoRNo53z+bzGXP5zbSSCwS4uDDg1Nzo9PzEzRkRDQmJe0bz/d933P8tpNJRqLREIefHp= 2b +GiCSMYlGJpPJGkknGZFocoSIjIRHR0TikdCISAinxgZHh8dnAxCHIASEhIaGhBDw0eHp0cCjk3= MT +rJkB1gRtcHJydHZ2dnZ0cnJwbII1QAwYYmZmZoDAmZkZmZgtWzzwwIMSSijhypUrWrRo4cKFSw= gh +hJAlSxYtWrRkkEEGv98PCxYsJJBAwu/36+vrkyJFypQpU/r6+j744IMpU6ZUqVKlr69vypQpUa= JE +4ePjkyJFypMnT36/nxIlSvLy8o4cOXLkyJG8vLy8vDwiRIjg4eFBgQJlb2/v7u6u2WwODQ0FCR= IE +CRIkTZo08eHDx4gRI4AAAYIECRIkSJB0u93f79ejRw8ePHj4vr/dbt/e3iCAAAIjRozEiBGjWC= yy +YMHCzs7ux48fLVq0oEGDhg8fPogQISInJ+fk5OTChYu6uroePXq4ubnduHHDzs4uR44cZrNZhw= 4d +cHBwOXLkGDFihJubGx0d3Y4dO+Dg4OLi4h544AEHHHBATU0NBgwYc3NzE0wwAQ0aNObm5ubm5t= LS +0hpooIG4uLgmTZro6enBwcFZrda2tjY4OLi9vb24uLgVK1ZEiRJFTk4ODg7O6/Wez+cVK1bIkC= Gj +Ro0aKFCg8H2/ra2NAw44kCFDhgIKKMAAAwygQIHCbDabmZmlSJHChQsXaGhoJ06cYGNjAwECxN= nZ +GRsb2wILLGDbtgkTJiqooIIQIUKMGDFibW2tqqrq7OzMhAkTS5YsMTMzQ0NDG4/Hv98PDAzMzM= wM +x3EuLq4cOXJwcXGBgYGFCBECCwsrLS2trKzs9/udnZ19fX2pqamxYMHCzMxMTU3t7OysRIkSIk= SI +WFpaWi6XYWFhaWlpZrM5KChITEwMDQ3Ntu0EEkiA53k1NTUhQoQkSZKECRMmenp6T5486evrc+= LE +CR4e3o0bN8BgsAgRIs7ns5eXl9lsHhsb8+DBg5mZ2dvb24wZM+Tk5Obm5uTk5GrUqPH29hYjRo= wX +L16gQIFibW1tgQUWSEtLI0GCxNnZGRkZ2fl8FhMT8/Ly4uLiKp/PZxEgQID44fxe1/Wt51pzOH= yX +ybvSV+Y97e/knK7DuU3XSjFZzPM4OMqk5KWqRn59jpLqOC6dWj9UpUT63TuvNnjoFdvF0qZyjc= zD +Y/tY3KzeWkXjlh8Gy91md+8CV7v7GJdNpD+BtUm22Siv3mJEXt0dyVuXe9VLKLabss3qzUTE5d= tc +X9/wbRVvn6y4tr7UsOGWPWUcl6nZPo/i+vPJLD0roZTyYdDDFM81LZbtqjXppMW2EwffWjfTVt= 5X +IW0Pg0vj1wdyrbSTjlu+3edOJup9njpTj8hpuR4Gu46QqMdrHYV001NWbBOsVzoiiQ=3D=3D + + + lTWXWEepp2S4ayr0k8LqhzOfHRuD7h+we1O0z4nw+mvk30smvjehU2R7U5Spaqp69FJSwtZIP= 4xd +BjYSV+ZarZmM93lu68qxzdNlv+zT/L3ndNhWhmk7fO+1netfLd8t88eSyMrLcn2UInGjTFBicb= WI +iqk57JXAQp3qa866P/BQsV3Madx5LtaWB30YlDLyGttbUa62pjKDfVsYJY3ir6SMR3gR1Fjnjb= iq +y506/sLWXyRn9ZYiOi/ZXmGq7m7VZd6qib7W5rPu2lRmXSbCUs1l1ufxjBVmmeMyqmx0GAxL8q= uq +XE81E0p280zgYlYK/sI6oT65evWZSyhs9PpFnk5ZsfUwSMw+n8dnTl6OLdk8UtnzOB3n9jCL21= QK +PzTPvhKS3Hc5DYNQ5C99CMU3RbuWwMrMqlhXkzfCfl2pwqXk0jSKBfaZTOcvcRX7RA0zp0ll4r= 7L +RZ4u3XUUifWnxK9UmYo89sx9GMTyin2ZYGVJO4lMbOta1B+dsXaSVVgW+jX2pY3aSpadxF22EY= ps +6krc2twvERdqZZJxn2ryc7+pyOyuZBXyfKStoGYloncrFoVi+VhWzi9ZlZnPQmqzuhaU6XYKc6= lW +JrHPC63jM1FzSh4em1PyF1RoHVtRyVkfu72dwspuVtcaWvFM8BfZyvkdBrGOpFAsqxlsvOKHSb= RV +kdmVrPp6dvWpqyb3LHV9YpJxeS5xGFXUuhK3YWW2Eapqy6mr6Uo29qVd6lZh2WJflYIaQ4XjrS= JR +J37J1HsYHHs+maV2l+npyuwqjq+qVGVSp6WUKKtc12V+l46dk+56Cak9Voueks8PV9Q7uOVLq0= Yy +9Rvt7TqblXNNwU5eY+aWdT+yjkWJdj0MWmn8itQeq2JjSFiq2Ar1JP3y+hA9kmFtpaNNhdX6IL= 5S +xWJdTbCmIyZ7GJwKjVFcn26p95J5WjZyl1hFYbunp3ZWlfTmc722ceVe63aP6/zN13efg2m1fH= /3 +PK/s+56/kT2fB83k2hfzdrnWb5qvxWGazJNzur79m87JdVms47mP3/6d230dzmmyzve0X9s5LR= bv +Nr2L+V0nh/cdptAFHxIL/Lz8kPc8wAaLMP5/ji6SsPL/CtjqyaCc+///J1LNcIEJN4LaEEyGDD= Ax +MlkgYZkYmAxbISisEIeUiYHJACMDpMGioO+MBigDEwOs6bKgBQmYNcAYmF/OWBScGmAMBhFYMn= Cy +obmAM3Qiy///JwDZYEMzI7S2ZQQx0E8D8wYXFZ7oOzUztNs/4qjD1B2VrU8Q6JyTwd/UzMS8/I= ph +TTz4CrIBysCUfdhdcYIXdBMmjFBCiOHqCDgnCKy5qdbIckKNpJscrgrIcnCq7kzocrfj1MzoJF= BF +RwOYBV1YgBLdAVILYUuOoBchWggNaIEELpBNkUWXFYzYORwLLYQZLeP4sDhBYAy17l9LcoNMGf= fY +AGUy/KKG/HLOlyIwJljOgGzCeE84QWDMTbKEBjGIbmhkxKL8fH6Oc0aWE3wUcRTAkoPB5ynIli= 56 +Nk8N8Dd0YssQEVcFKmh/km73DZJE378l5JwbsoRTM/PylCECFxJF7Q8n4JwgMAaqBwNUeLNvam= Zo +gjneCaiAyAnSyOCQ8xrQAgRNnBogzxcfCCx0bGhmYA4o22AvmxMUSuNAATp+bDakhfBjAWuw4c= Hh +SqDAqENc0QWFBIpsaHq0PVSQUvX5JWdsaUMGgTEwdodwqJPpLJli3hhmZERERpKmAyMWICEYFB= KJ +BwRJjEGAsD4cE0BBREgB0jAQEINBomBQIAbEIBzDcAxDMQyEQAwFURAKMgZVkwwHKAfodsr6Fo= 7q +mBJvoD7W8/0tXKeAFuySRbVvQQ8B8BGhSAJ+a8BhHrJDu0Wxl8FkCbiE5SDoek3bskvWnJ04mJ= mI +iyxHmzS8BUWmLQbaiVcDRpRU7n/OORIRzQYhAsysrTn4hN6gZs9R3lLgnBByUPZ8HunapHBtm7= Fy +eTZR18plCnxz5RxwQl7wzlvRTVPqOG0aJrJwkWFx+0SG22XI2LbqNNCtHwvOs+z/zdFMtqOZpR= 02 +NIwiNFNw9t7K+Qtmu2Hna+Vzvg0Tkjbi0MfgxvKiWftu4UZiJyjgnbe3X8y3R+BpXnUMtQmZSZ= tB +UkbF5mnnjStZFQnnKxzdqmlhK6RhnKPi/fHFG8XiGDhfrrpt/bra0RCPVK3o4zHp0vWsfoSqox= YO +MAD2W2Lmdw2qGffTIMwyMhioTnrzuM/0vDR0CFsiW7qC82TT45DbDBImUzj3k/H8EOee9uXggg= pX +QsY1fAO3DdwCFgIIMaytbL/vI51VvO5RYXHAsZx1mptRFpr9n+S7iDh7J64h5P/aKKh75DjGIR= tC +4JCOrGIPPrSYiohvtQXb9Ej/rnfsxs4EWg9mzsKaszj1OizSSazbqJl/EmxhvaWCYJRJAhoEJs= Tz +fzvX3ZwjpiibBEOHnyOolIE8bdyvn7U4nk8GkQC/PU75N8/dOhFYGFCEqnK6gDcoZKIQc+u8Cq= Td +D0UzQb5R3MXPcZFAQeYtWeSr4X30rnS3bgZvU3V6icxBtaRvAvlArSJVJqotGFTro7aHg+P6cN= 4b +4b+En0PqkOzk6yqLYgA7toZKtTjDJ+ZQK8LE2t6zEFlcoWeiMfIIliaq6q3zg0PW4gGQbFiaxC= Qm +IpGmdSCfx3ME4UOkDsxNQ3aSkABYs+eQBeNA78jclnXpvuslOyuDOLnywL6q1Txcsdauu3hr8C= cv +shZ8nhsGZDJkgQB7DpW8myiqYkqcWybGm7MXCUfdRJ3yymhi1srzQIs/S3HSl3Gk8O06bC+jOL= YT +u6G7ykhJ2wlNsNLUvlJJhZ2weRwRsWmWdqQZHDOys9fmyzhJ4rNnkJ7VD1ZtjKuu0vYES8lWLW= kc +JoD9QBV7JixMxeBz570oQ92yP/Q4ORNULIqL1a9FGs57JtOgBie+lDji9OrxWrqmnyTH6amRwd= yY +husOymm4ixkZsmltPIuKdwsCJk72u6OG+2PF1MODAYX4KSqt1fPUvaUnztRwXnpLcOEngjm/5k= g6 +LVPDfc6RVinxPQWkVxZWw7m+lBFEjSccp7nVcC3pCdcuUrUmkX0zimUNdwKbRGJaGxcKaQBwW8= OR +ephAD+rxrEDk65wcxrCDEMH/Gk7kDkKadthwUJYNMh8ke4gN90Ne8wGCfLwOTGamVSgbrqHXwb= Yk +WoxxvxtgMm4ezIYDBJKOhjFT7EebNlyMPw80aDJwJQz0MGDCAOcGQGrDEcBTWiA1aUGnta8p4I= xs +CnSMMtGA+9kYdFT/BdiHXBzwx8WYo5ZA2pqoBfBnqZxy0AbgBm9UZLksSqXtLrZdV4FwzMO9DR= ai +1qpv2W94WhJ2U9A5SK6YnR8m+bQ2K6o2p1HMbzUJdsI3DHhJ9s82eHKfRSrKyDxO09W+KemEvt= j9 +pjWbfZ10eWn1/MwHPBrD8nR0S7gUqBl+j/oWHnqvOwA1zDsgHb164G4nTVVJlMN8xW5oZ5p3iD= 1h +gUJ4fwen9wsi73UsgaZYsfIDTKMr05j9YFsqcg3kJpNP1MTEAh7b2YSavjtPk1Aoyh46BIj3xZ= pq +Wq8zdywNralvT8ICT5rWymia57Ib75LWmlrVJQZFJyovDcmlEw8PaGmM1eLCiTHJCL9uask5NI= 5Y +/pWk6SPghF6CTQytJt9pH+QFbCnREJpkIryAiVb8jNA00/JvWbbU35R1FaGgf2jQfUk1IbhiIi= h/ ++VTkbqsRq4M3RwayOH7+UduIemhgRvuO9rpnXqGAKkPzCFPYsi72ZAWz/ZHmjBrjb83Ntayf1S= CY +WEsiBd20fJrjGqPSOC2JHJboeXiUkN5rMIl9VUWU4G36CLJ9RTwILzwYApp5PSzApCoWx9b5Rz= R7 +XoqN2Yt3MF/zkd/Cq7GBnxZRzTCQYYDU5JnNjZCfvCiscRzP+pHai2B3w7Zv0BFho7QGht+yXV= rL +bAJhJk9wxgZwmEghi+E8Q35I01NVikoi4VMWnpW9P0SZeN2E85zie9e8Cd6hkCU6buLOLfFsfd= JI +4xxm71w9lXmoILGdewgas3M7QEcfN5KiH2E+V+PDx5iZ9qz3QNYKagJN7PLZgn3R2mbYI70jBr= Oc +EqFLN3YMnakVsBGRRISwCdhLWVuwzbMNSVBub8lTIZRVVLJ3c0GYQTe3YQUkt+d9bGpqOxR37k= LR +aHoByFMGEDNF06m7IuGKCe3hE+Qa50YTNnFxN0/IqwaSPvPuAeV0D5eyN92yKp0U9hgliqrvla= 3/ +kDZ8+yry1KW50ncmGXkOWvJcSgqTD0EsTRDzXzsI/HSTvBNphfQXjSY7VE1Mexn7v3bvu3moQW= Zp +grQoN2jDpbq7HZYL621p8u2TIvwlsP+lZlsrmbnUEI5yFIrpQNRWHwddRXGrVpW5yuxDBrk/Te= 1/ +ZSOwAHt4DAu20fO4CZwmbGtPwOfepZy1Qw0d4Su39uaniZkiD+BmfrOi6wrljmHoLmoSK2tS41= jR +eYdSa3q+vNREtnBoYPst1KpsRngssrylJqHfcDTz+WF97DHn7yOGlDBSkfK85QGh+a499HqS4l= Iz +RO1aZD2RB549KQ/XSxMnwiPe0ZoAukIx4hGmZ9KlOOKKKBeH2EICiAyF6JbCJNzgvYVx94qLsE= Bn +EPH/CWauNmqK+xFxt0+vSRMuxjegCauj2TZDbo6R5UPnMrx8yFmMLB86l+HlQ84yZvHQu4TuYM= jJ +Dhkl9C6zUQmV8Q1ADYptoLqB3JoqnADdfFvrZ1EvYzmfRwUWHSR9iGLfIgzZKuhgmjGc2hWPUK= 9f +JkXhTs6AUR1uGn3XxdVpSnE/6CHkLy/8dVF9nEOhA8VROC5BAf9wCGVB4DoB/9gqjqkvLpR8I1= yM +26t5FWGrAC3KQ3JLhzAuUEFzIPVvxpHkYIOh7OlIDFbi0Dg8SW4VlOqTg4++4SgC3BZHD5B7oE= Kh +8jh6U0elBZZzsouvy8UvfFlS/vmWk0Ck77vQfHFxWltFP4ao3PP4Hejlftw9aIxb8CqSKAPrJL= i4 +FMzOrFruuLBJThoRDqlEnRyW81X6KALzExyPG3BCI1eBrY+LlDhmlQxX0QxwcYCulYpVLhFXSj= IW +I+JeFwB8Cn0XYVwsW8oxKlvuThzgXVxRX7j7MFjFkJLRVt4EhjiebS5J/TQzN/NDhNId4XBj+b= pw +pH8dgv1hsh3F3ZdtUSy2gp3YZ3n0XFLT1BG5HMsdGRQc58ToM8BlfniOGb/tWRzi/N6CTTkviI= W7 +g4PYf4tHnNyu9l6afbD/+5Vz6bkIXOGG93Z0s/+6T8lOWmQ6hxFXOFjd6eiWC2+oTcoX1sUGJu= vA +DWC/FpAU3FKFC3cI3z9hG45kpXLhyk1JsMpdsz4UiBcgYQ2cAOgCM0oX7jS+C8d3mfcF7Slxao= oS +B/0bNC/cU8nI2CqQ27xwReoJamneCydr1GBGfeEEROcG0yNEILVDAoVhskNOST3ZLw=3D=3D + + + XA9PsZFcqiAKiALDEV1zyg/CdJNwy8hvsWC4V9lvN0QJw2H0H6OG4SgERAyHDdBiSGI4mtIoh= sPX +2ErbBnjL+zeGG90AO9s41EIfHytkAa0x3OK2cVGa/h+O7PS4+yn3IsNB+AoL/hKxA7aUpnMgFb= CN +tCkmw83k07hfjY6pGia2e8AibBJrGU4ExBvHQfa9hcQMrtCCoxfwDWf7qYip0TEnGhecHJ3tLQ= CI +Rf7XDEeYqvU4w4n3RiS31jwAjGde+sP7aJOHfCI8TObVNiyVneKdCWQkL9ER8PKs+8cC0B+L23= 5X +bdwmuSiIRgle1yY/ryj/w5hN5QYwiKhtYNHtwOhpiHC/tP90TsFtWB0aSe3Z+BHm6/NdjPvnh4= Qa +i9xxE+E+999eT5cXxcUqkkAoeST94ZuEKTdeRsQkdWtbMoHipLRfMCfcgJ0F+wJnwHu8zjr9vK= ck ++79k95DGLaIMyrsmMaZ5uIXY01pXFnp3btuECFMSjRS1hCkmLF30woAfOoPD2onyquyVEEmGQy= eg +nR1+mjKbRyEdfFJNlJdPSLMglYCOwjYisgHbgCxg+Flt3Q/uazuTs6wicpdYDKoPM8tN7IZZzP= Ye +7ky2/JPsQOWKe3xqgUdM33ZCJHIctOUOCMUO4XfL5gzrBQvp0uwf9msAn8JSJgh6YjPtMxaXNf= /k +h7eyhdEAPUQbL2set2M9VhcHNk6x5+ILRkeUkRh84b14LXMDLWxY6pPY2NnWwXhvVa9UNjJx00= Y+ ++I7XNo/r4Vv21oaU7ha/8Gw998w9XpRwxOEsGzUrCATBH2tsrc5+lZAJ7PqEarXKw5DseF9w1Z= bY +t9B3DFssRYKlrNaj8Mc1Y+ksKU6CknBpCW5kERcUEE8aTaKtUZ0OlSoDRp2Crix2xsPYMmmjT1= Ci +WALS0XFMRIu4JHDsgcSijMlEBXNVovuk7W0+OH9lx6L22UIBagRNNTpKhCLzHrUDeYpGEo23M2= co +kZuJNRWhuAXysBQ5K0eYmCbHiLgYnhSHaJoXbkKWiPEXKFl0dKMUUxP0a5i02YSZ2njKiiUwoJ= Jg +OooUBQcN0hGUgtriBvPj/lZcZgQNzPRtPpTL5ewU1+IusH568M6KEXHKqMlVxjKYX3+4bIJqdA= 0X +V05InU7n2+I23U3qUVpUMG1t6eGGWdQQNdkftCL5J/f1PFk+C27hXMoqN2ffUASdbk2Bm8nh1L= l1 +bvrY2u9NtXC75S2zzuYSuTYIC9QsGcT9tA/fQ33ZepfU6BXR+ntLn6b7WS9Pz4TPp2rbjuZQiL= 3Q +hhLjHTEyyuQHznEfdG3ZJzg8GFuazvzfBPVyhhEpPCOfm5k9TxO+dY69rgSymjOclYK76eYeSt= 62 +HA6pP4dZsw+4emyOAZeIRJ/SsDPVtvKBzYMY0mgyiiIkTJG14bC4lFAlmwCvbiKBWRzeL42aot= wY +b2Cg0q1sMqNRke1C3hGq1qSG7RCKUHFpa2rC9BksuMbrPUsHDEKTTU3g0q4TDONSB8MbqEof+/= OR +1Pp2uFz3xnxNKuo8b4ETW6hv5g00bYJogxV3fhY+VKQCxJsCJutBk0tEXqbsQa4zYrrQ4LdyaH= P2 +S/BdU103t9c43layPxHxA9pS00czLQW5dGWGzJ94qQc2FEThewTm4JIkvCspupbFiRH9lLfqVL= /A +Z1huWaTKMdvyCq3dS2HUN9V2aZwISlBAc9HootkUrppDaXWxlmLSrxjWlD3zeDfREMBxTj7aVe= Qb +lMXWjl/Yqde7ZArellFT2Aa4PFbyiHqdlzC+w/+PajzfALZaz+8HHfxofs49xAQGIg02GZEaAH= uY +KRGWQnVo52fdk91wgC7W/EJeDDfPJa4Jl6IOPVQ0A8RAyqjOYb8U2ZoNnBFp7lLrOMPWLdZ08i= DN +pyREAyKCJUWyAQedBVF9dz3njyba6jMATZG2GztNSEzasOnOEw0A4CVPnZP5ykdaEYSfIi49vD= gh +vc1zvPIzpjujM5fA8/V7E0VYw4POUT6/gyNjWtnkhCsdayCy1dYUbqr0uxTPweDYSt024Zbxca= Fn +jPsZhreT2R17NKVe3tvRj66qusSZgXd7TWfy9+IT31R1J0t934lkVYQuG8HiB5qIXhIBh4oJTR= no +bDoQEs85FAkH5FzddE0UXiFDg5d5KGT88aa4YaepFNv/gQrF1kW9+h2aE8NKYBAkgS1CrrZpe8= Gf +kVfEFMvKRROF7eSVoS2gr2CmnxZWTfbMcCuEF9tqGQVmQ05yulQJNQh2jpe4Ze2zNvdXUnZ8qI= F7 +OKK4Ko640MWOpSTcFQds5OKU7pNxX+64OEwJzgWdsur18h8kws9D6Dki6EjAHDXgbIckpnEhJ0= Gl +ZeYMfz+WeRXgyPEHRBEJ/3qn92gEl1KCW3YcuUkA43ZVRyxKCUdOKNUjjhyZdDwcOT4RPThyO0= gJ +Ln04cocIJjfhleB+o68YE0bBkdvD6olvsMGRYyOJBkfuvm3ksJcav/oKxymlHKZiQX2pGE5LBX= PB +bsVeqdDEKhU6O7aKin+bjpY/CVKGiwvfhkPz69V353QpS4RSyKS+07IYtA30gZk2u+5jcvS9AH= rf +cC9QQBiudP+bTgX6Us/qEMELoOUJi+S9Re/D+vM3kYJcos9Iu5ni+m7dLQ61EJCQvbfnhLrf/o= bI +prS8/Q0rpZQySWnSk0NZcZThnw1dXsdKjEh3ArIDqAJBQUFeXl5IkCBJS0vr9XpFihSxwAILiB= Ah +wsXFZcSIETIyMjIysiRJkihRogQJEiRnZ2c8PDxKlCgZGxvDgQMHEiRIrq6utra2lixZ4uXl1X= Zz +d4v96X919w9rvjw87hLjvcetyTlqLE7x9U/8K+8kf+SXX2LcklFP7WFlld0fVjkbR4nZkELtho= 7s +lZAeN+PAshwFlbtusM7q3JrjWv10lRQIGe4ol86HdGwMzOzuxrJGurUzSqq7bXUs2A1vqVb1fA= 6y +kQ5lqOrbOVbjwN3E7SgO9CGCmkJHPlTTXalnD33f7CHV19btlWprqS5n/ZF6jlj8aamI5yhW8Z= Ia +O83W0opdh17fvnvdj0NNH/yyWf9+rXd46TulFvsOtbXX8f0aYmvrrftq7eFbi3+Vusa59P2bdb= Ti +tBn/3PhnZx3x9dG9938OMbX5XX99p1rf8KkFv7BvXWl2m+sOKbWgrm6/r8O3teqLv/q/pmG1VZ= Nl +Lqu+mnSs589FPcuS/Hm//qY4jvanr0+DX6AO1FHr+W63Gevw663WaQ5rveBX1ZdWvN9DrxfU+W= e8 +w/rv1CnGbkP/z1rj/TTU9jXN4733viV/c5NaT9f4p3h1nbhup7r8/LXpX9fYb1gvz9Zr9Q5pvS= CY +Ta37/2q/1WmIs7XJ75+rh24rKEGVjW+/b92rg2IVtXFM95i/3OIuff7sOE7tK39mn6Vz57eYOs= Xk +F6irdW9M99a54vD6rdT9ZpvD6hfUfYE6u+3rGmr9Ot9w67dYb6c305Dup7fcI/45Sf4wHafTu2= d5 +8U+xinra8VduW1qRuq2jk7467lm61rNm8ecuy5/6V1aNRUcijklbb93jT3Q8c7n11K5/Zs93+r= Y/ +Sqv1Vewr8+iiLmdZUj13Hn+K91dOH6uodd42hnK4mJmZSfJBDY4IvIiJopHBAuAekGlrs4KsAQ= C2 +FqcdDFpssPNipoAnGo4AI+AKSxABA7wQ4MZA2A9PaFAjBowXXkU8yYgBI6eBEmPYbsxM0IQXIT= Nk +3A4oYhNTBRaeGgXMPIBBGTJKcMyIgQNLByuyWGJJARehkzYSgAy45SQwAgyJgyiFJBoZMQCYEe= oA +iiiM6NCMxdCjcWpBiitEcANkzPSuRFBq0YLmAK8gbESARBPNjQVMkGGhAQNkEPACXGAJGCfGBB= DQ +JozhYdqoggKcG44pK1hogQQECuASbM+YD74bSSxQWaK5ZQ28IMHdpKxgwdqRQpgpRggLmEFjzN= Il +AhozChjgpnWFiiqbZqyLWo0ZNNCS0GILIpZogDFgGHGCio0HMigTpooBMAaMFzbcSRRXaPEaM0= 7a +iOBmQAd4LvASAF8nCJYlgtSAMWC8CIAHDG0rLNGANyVGgFFyk0NPgKQnX9rayjzJcQHR1sbljM= aM +Kitk2tqssIK/NKlxS0CsiCu4INl4EcUKNbgLxmxBxocDPGpWiNmh0vh5soQZ7uYl6HBqgmCnQy= Ia +2hbIB986eXIeyAFNnxwcm5oFbtQwgEANA2QokAANHI5mhowYMGTcuAHjgBgzLly8eOGiTJkySi= ih +xJgxY6RIkUIFFVSIESPmy5cvYcKE8eLFCxgwYJbo0qXLli1bhBBCCC5cuBxxxBFBBBFEDz30AA= QQ +QNTU1GzZsgULFixXrlzRokWLDz74QJJklixZfvjhBxtssOGGG27IkiXLkiVLeOCBBxpooKGpqc= kE +E0yooYYadNBBh7W1tVwuV6VKFTQ0NDY2tipVquCAAw5UqFAJIYQQ2NjYZphhBilSpKChockggw= xs +bGwvvPDClClT0tLSpkyZAgUKlNvtpoIKKrTQQgsYYIABGxubFStWokSJcsIJJ0yZMsWJEycooI= AC +FChQQBCMEiVKkyZNaGhouLi4QAABBChQoDg5Od1ut7W1tSGGGIILFy5qampBQUFHjhz54IMPnj= x5 +QgIJJKChofHw8HDAAQcjjDDC2trakCFD0tLS1tbWmDBh4uTkxAQTTKipqVFAAQVpaWlqampMmD= Dp +6uraYIMNmjRpwoQJk7CwsCZNmiRJkkRMTOzKlStHjhy53W5nZ2e3240IESJFihSJiori4eEZGx= vr +6uqqqakJCwuroIIKAnnX99/aXrfhxS9W2ez7FOd6PW9da76Zhm6jtdtrr9a+9dYVW7rvrhVf3z= p0 +G/r2+ohLEb+ejq2e5Cj+pHas8y0WRxGXFNT51XjrHVab81ddrQ7dZvCLhrpmULe39pBeHOrHYP= a3 +11xD/Pir1ldfz7dmSyneG99ctdtsnYZu81bTTfV+q7Vj7FZ/3hjbvTW2odv81Zruim3OGL/Oru= 3o +G7HP6S7FPV1vcX7VP62Ped7P5M83lpS6eK2IqfX9ZknmPesef/p+Pp//e5uppbfmvWkOXecnt+= j7 +8dqsfdb/jbP6xp/lONK5fcxlvSTOazFRLSA9nuOcHeWsVPKY6I6SaYc/RZ35HAdaCQERa9YPAp= Lu +6Jrj3kwthZSsS6lH9uoqze4V7Zndqa8fJS3DS1QYa9zdzIWBROUgHj5bdRPlcOnYITmoimyPnw= 4S +UNONSHs9G8lOHXpn/NmGW2ceD+x3SX+eqfu9d27tG6dYjj9JX7bz6v0jSUqNnoh6WBuTQT44++= jK +GimX1NVZHIillbPxlBQWw1VnPT3yr2ooCPP48GH0WUk8KbxjZXtkHha3o1NY6IfuosYdPlWkNd= Ky +mQvCP3SJCgP9aJHVceCPFNFONdIBETHt6GztPChD+Q1VkR0awoFPOBAH3jCRBWXhQA=3D=3D + + + HBjiDNGRw4E4sKz6lFo1yQgKaUipEolppB8zuo+2wPAV/tERl4TOmLxwTFpMuOloCmj3E/oiM= 1/S +Vw6inhCdlZRZaQYkaQTLEdqx4w0RjT2SZ2mriGkIk+GfLtfk5KRjwcSIdORwR1JNQDriTcqNkU= lR +x4E7nqSUC3GalJZuemWiku+vzsk9kSXlrqR+RqUyKRwdOa3fG6nMQXzTx7SGedua699sQ7qxzT= +l +bp9etzfbsGr8xePdGup9QbBhPjl0rBGPx0SnbuJAfTlNEqG4gKivCqnmHVavGHuuFH/NmW68Nw= 1p +ptjufT3XUOPKA3lgNi7eMVt6RV/1kfNHH+f1+zNbLU6feEk8lhvHjKun6siaPfmcXSceSkcWJ/= yz +C2UzSXEg1JTSVjXT4iHWqx2up2b9fJRqk+eeesPbOXuVKenYITtLVJi3Y9RTITDT/XxIki+I52= zp +RB4eWV47joxGnxIOxIE4cPLgcMfUsQrjsRRUNjUFGUK1BeWzY6oXhfQkdCbVE5vy8jF2lsT1w0= Oo +nZWS9cnq/QD69bC4ck1nQHZ4xDAtHPiiGNTW0a46iU/1ZpJYXl6SP6OcpTKs7NH5ctCtLF9PlZ= TR +j+Yw3QTBeXsRBfkdppsgQF03WL/ZkzL64X4ry1dWXollly5nqRzJvCRxIFU98nHnVJ1EoSBiUF= uT +J1eWZfZNZ0BE/ethNdm8dCWUoXZWOj1KXD98Yk+ayqkndCYVhDXVixIbMu6efvDKpqahaxXG44= cV +GA7EgUtTTOtoR4P+hwsIB7pUeENVZIuoeEyUx6pnI1mdkQ6PKtqFTDqlc4kR6cj9sFLCgUI5MS= FA +P0M4OnIXpwsTg36ojixeUE5MCJDGURXZXO+94Vvrl+6KtQ5zrjZvN672w0yrTcVahxpXstL//Y= +Y +dJ//5TjH+/tZXn3neEdb9dv7pbfeFYfVef/68eNK9a1P8Tum/6FjanNdf6bve9ca0vqZeoltab= 2c +Fuc9rZc/fT8yT3dRpJf0/+LZPM+pda3DazMIFmL72XV1x2G2+P78SS/Hxz48aR33zPt/Ovm701= fd +Ziev5YHZ2Lup36eUYhtm+7fm0O+++PrV9fXO10O30Y9t3lRvnG221u3rqnXeX3UuxytSUusvfX= dS +/HuSVvx5r4/TV5K3/qqP0n3t/jA7r1rrO4S1qHOZaShUWBmSmZGRohwOUxbgIBA0EIjFciiEEG= CE +V3cTQAGERMGhMAwMA0IC0aAsCGMYjGEwiKEQhGEwiGEoDEUZhB4lywGB1E7faCDwJDnm2BZgEc= Ml +3/bw7SzXFrMoLA+8YRDKg08yHi70LmQJsIKLlDoZtRzehwOgOCGlcEL8II8oV4EUTKgGcSfG+a= HY +0x/7B39PYDtsvFrK5Kd7SOdFKv5NASNJ+PQCRvwVrgCMZO5QHP043IkiYORxBL6PEfXFAEY6c/= /W +JxyAEQFxao/uR0WPePyuYOR3RwnZGGzy+N0V1XRw1NpOar+wdtK5Y7SZ/JI9fjd7jSQztXt/Gs= gG +CM54oOzDCI/nl/stnORW+X01/5KctvsdLuUV86kFOAFjHA5515WAR0oQVldPHR2Dw1jrHoqKaR= KI +Z2zROwIhlL69cKQjCq4Z9ZPOh4SQCFPO5+H3ZI1RPOKsw3hX47FjDLvysZnIC7VmXJyQNUwLkJ= 75 +3OJz/BWRFNh0fzWkuG1WA50Ci1B1QQIIP/Ha+SOW2NzvTlXkfrG7jlIDoS7IVbyqUzpfbyfQlU= zv +HAtgsAvEBkLnSgo70poNU9h9uQzCLoTwPjFIYJ3lLk6RriedngKWbndPcavmnCBecQ9VjX1xbK= zi +59Ht2P0TEVsHvhBrjDc5arklLW7MvI6Iie2CgcWwAILaDTPCAVdY7xt2p8lIf27nT0ctvXR6k9= ju +ghFDZVC0pe58VTxppQ46AJDK8LpdigZpnXpSlB7OpHcNOv0YNUpHuuo+dRZoVTT/yhv1uzsNq+= RT +7kOOW2kSR+yY9Ah5l5eu5umqt0dkW8JQOmwaOOTeTiDhRO7iOs8OBag0Drx3Yr+jXH4GfhEIHl= Bf +O3mq5DtH1gV+L2p0e4S9YzOm2pRhSBVZTP74CePVrEZ85xzrIipZBIPP8ADO2SHUFgLy2ckUCc= Kk +GvHzsYoOT2BFnBuKAwr1lRFc8l6K3ruOGVpF7UFxsCJPI7CioIzUiKhyXSoOzWBFPGz9wYqsC7= sZ +nQ1WRIDYkAyGzWi3gRXFiUt7nhDIiUUZ1q5oFTU4KWYUdVO1GNRC4w7eVcES/XF9LOLQ2gMlQp= Uy +GnSaMtZvg2vSaSsgE8imUsYzV2ltQ5zqwp7YhjjLOIpPbXE2GWvbR7vnfu+46Vu1Wq90csEbDZ= kq +Ts5wiAmrjH1xL6n7lOfvSpYRiBefBrHvZfnZRo2E5a9RG23oQsg2cb+HPltrIu5lPppPAMy94P= Ka +6P2eTDcXR/i+UmZ/YaHuHZDBRHsEYH/6VEwcug0URoZLldcEATvoMbL5BPH2Aw0EFlPzibvdaF= 8e +aMgzWaHlmBO8o+EnvKo4DGYeTR44YyFWcRybphVN6xgNcNU7UBAwC1uNKL55RvKrqWnGbmbIpo= 0S +Dq1yIQwT2QZQs1tElSdCBvQtWbkC9q25j3YGLblJ4K+bRlPDzRlB10BU1WTND/H1+nmGgDSfVv= kh +7iGfibgnUY6h3eWHeN//5jLG6avZPx6UsBxQDypXGX4iVglkFWLLQyvB9aQcQysX4ulXwyr8q5= do +ZoFVWrE+ZvEM9ncSl4IDalmo4qoZwQh8Q5XQL5551StYxHZiipKINZkEttxPLH1mAerL7acTpS= lU +FWrb2c+pgrw3444K7JI4cARtaQj9x2LS5QM5X6rRLOz++kl9V3g+PSKXmVLPMUyzIDcuUEXyKM= Km +Km2qkIDbomqjDpojzScaPzskIrul/GXVtp0g3rEbkbsDwF3ZyTNlaT7SHchBRX0k8aR7uN/rQa= EA +4Hr1AOg8kCtz7b/witWtxJN4ObVPAHCJO5lSRPICktInIoXoTjGvZlVX3Mv5fRD3sgQAtxiT2R= 7I +Xbbn9pJiQqZPMfyRAu6eAHD+91RyL14oMCnCaoBUwBvemonO9a1GVmkqm1c1bxVSrhuE+g12ct= WV +PyUtn9+vZK5hFqeLK+Yy7ItwMukWcZdm3h8i1JDL+h0K0Xo1qLJnIHgcx+j64gdfGV8N+//MfP= XA +1fOw0x3KMe8v4zvmv+cwa/aJiBkkIjY4YK4s7TaJ6vxsoMQbm1k2Jo8xDQivMaexCIcZsO8qhs= vN +inZZYiH/fKF7RMQkWvbzFnRZPVzD0guH5LJ36n6J63Vi8fceLGV8ED3GF4AhqltV9K/dvTUZtl= jY +ZMNbe2fWWBXF9KIGrHfyeRmVPgo+AEcQcdXQ7nnkfzDjfgGqjG/8mf7MlSZgK7uxh2LnSwqcPT= yM +nVBsWjkmZXxg8aZGVfWGkoBVcdAu8d/HpnZ7AEGHC593cupNLotbDhzv2ZJ98ZUVQYY/rFy2ac= Ir +9WcS8ydlUUqEZTIg7YOxiDK+sGxNAfNa2qskWh3SHdrY++D3u3ynxutn7Fchx2I5fbb0EqD3ml= KX +j8UhrmVTDYELXLGpRSjjI928UkWX98XmkRvx8Bhe2i4gzDwbJLuCJ2V84pX1NuKR5fvVmCapYZ= PV +KrBJ2cii4NylceeiQowSiJtKINB4cnPr86l67K2jhINrku0VrdPFwvfRjDJUtYyPY/PZ9vl1mF= /7 +EEEZ3RMim6o4r1CyHSNIsmCE8mlK5Mm14xcf1xj7KvzE5H2vfb7xRHvKS7W/C7sU9KrStqP2mO= zk +jCFh1NAm0IcjJDvRXc1iSH1e6CrpklSkI02b7dzhOreZTejINLYP7+LhWiTBMr7mYupx7LcS5h= 9W +EJdwLf3T1eK6CxvXy/jaqmwSC46oByX6jXjRTbIvGJfeDhvzXW8QYfNWeMsxp0uqj8ceZx2RNo= fA +vfYdtJjUg4TXInCXs1NsG9I3L331Qz+kOWhst0MUd2tqBdsAOcK3Kr85zPPGt2wGNpCm6eZqIO= xB +6KM5wASjm+tBM3u/PZ/gIc1WS2s+GIIQYzKFfSseLtL5eksbZ/I2QFx77dMXEj6uOBAv3isCCb= Ax +5LXvf6SaUcDGA1UE0QbGH5upeoaVD3xDNkkgHmrEDFIzhnueezJTrDtpGpdXM1IuBrJC9LbbtV= zK +oZ+fvK0Xb1pDS3fallOR0FumzvovNPlZEhxJdTZtxbLuh5nAd9Mkc+YMyDhhyAmdCOt6YmSW4M= pM +01G+IlJ+vlxDn1e+nyZMFNTeY6shHQGAWGeqJfjgXMqIGZM7ql5zGQBiIe+uhS+61FCMvVDp1f= dr +0pNhASYBjtPsVFH46WuCxbXZCiNmkryOnxunFqDaZoy9nGsqoozRXXb7EBTtnZqwRMIkCP5daB= D+ +Ge03trDwZZQUBabCLKfV30k3KvL10CRqPQE6fYXT36opPcLIek9OLYJSF44QGVMEz0wNCGHHTS= UD +bh/ODspDoAEkKMOGBObuxGgo65GJVVsEuOg0XtnWNA0fvvwkmcIbqUIkvxBlw4tGPBm1yxPLwz= jC +4rXvc50N+mzO3R1VjONtj99hvJrVxXee4+lQc7HvDigY8MgE6ATSIXKL1vvWmKeSv/YdC+aOYx= D1 +LeakMTsFo9N17sq5DNlmsMVGHPvaF3WiD48lZ4QhlZq5oy08WbeOMswpPzcCJcPBMESyQJDwHk= 4s ++8/w2LnZxj/SpHAit8ii/yfb4gOYcCYvVxky8ZZCA4KAiYQMcCc51E8kXo1WPsYegSMZW7icW9= Tw +iqWZQCxCjxk9e+t7LG8miw7zW7FX97ZjYjQfFgeqSIJz0WIXJkSoQFynTI2nGhd2O58QvMtzDP= ix +BShn8M/CoHiy6QXPb5Kzp+YEGjuwyyxaiG0VlPtZCP2j2RgLjEWQUyzTzy48Lf4sYiTvgo8Z+F= xS +Q4u5VjEYQaDQzTng0ymyisbzDOGAnwWCM87TeKPEhs6pEtHs8qygY32EzD8vYaxGoANwSFoLD3= Rv +U9CJZLz054JqVVRcnqoG/npjwQJ7YInNyztyEF4XDnWpxdgotDozPTiJYsMIeqFObp7K/ECQDm= xR +jcE1XhIRkyi8ASazONyFKwCwMX+5KFyfw4JLCyx/BdzfP8Se38bMZMbhm7DyHPRWKA2/tktu4c= yZ +ICiqMYADFeil3vml/G3OPKrEcIlovh3NpkWUU/+3ijGtbeF3WmfU/SAMzKwAlHUwZDQqRTg8U1= kw +ZVBDRTBkJkohL01mKzYyYE1xIw0lQSohPjBKUE9DVjBLQzctMGYoRj8xYl5nMTE4MSxxM0wyQl= hT +UkIwSyoyaQ0lDSVDRz43MWUnOGY2byUlbzJFM05MMEsyOVIzQUVmWzBla3NQMS40LGgzQ1oxcD= Vy +XzdnMyg1aHA3UEhoWEljVTVyTShmN1JULWcyRElXVDEscV1oYjBiZWU1NTEtMGVhYg=3D=3D + + + LTRiOTMtODc4MS0yZDY5OWUyZWU2MDkyNzA2TDI1OS40IDE4MTExMQ8PD3p6em9vb4SEhAAAf= X19 +ampqgYGBdnZ2hYWFZGRkfn5+hISERkZGfHx8Y2NjhISEHBwcYGBgDg4OR0dHAAAAcnJyhoaGbm= 5u +goKCiIiIysrKiYmJg4ODeXl5hISEYmJigICAkZGRjIyMampqhoaGMzMzc3Nzj4+PDQ0Njo6OlZ= WV +jIyMcnJy5OTkmpqakpKSj4+PampqmZmZnZ2dkpKSnJycNzc3mZmZpqamzc3NkZGRiYmJoaGhn5= +f +m5ubqqqqoqKij4+PgICAoKCgvLy8AAAAlJSUrq6uo6OjtbW1tbW1rq6ug4ODsbGxQ0NDm5ubuL= i4 +sLCwoqKiDQ0NsbGxvLy8tra2pqamAACTk5O7u7uzs7MAAACxsbG4uLipqamMjIy8vLy0tLSvr6= +8 +vLyAgIC/v7/AwMC1tbWysrLGxsawsLAAaGhov7+/ysrKxcXFSUlJra2tysrKu7u7xcXF19fXub= m5 +kpKS09PTubm53t7e5ubm4uLi2dnZ1tbW+Pj45+fn4uLi39/f4ODg7+/v5+fn////6enpBwcCEA= IE +BQgdHQwRFhwlJy0uNDUFOzwAKS40OT5BQkdIDhLD+fONDPOMEA8VseX/5X8UARFF0/zddhILDx= KR +5tdxEgAHCQwQObf69cBeEAwRc9bIYQEHCQwPLpn16qRIAVrDuVIOJH3t3Ig2EEP///+rQhxfy2= sn +BggMDzCcMg8MCg0WQfe2Th918PONIwUSJcD165oxElzc/+R+EwEJDA8Zo+3bfh8CDBBH1W4QDA= gL +DhKF48hhADin/fvAWw4RaNS5UQAHCAwPLIv48aRFDwwQTsH///+qQgEibvH/44gzAQkMDzernA= QK +DRpQ6Pz60mskAJHz8o0jFDPN+PG2TxgOE3Xh434ABwkMECaw8uWaOl3VbgcJCw8dlOrVfikPCw= wQ +R7UXduDCYRwBEDaa/7hPEBFZ1axEEw4FBggLDyh8/fulPgEQPsOcMgELDh9f9v7tiCwnrfXyry= MX +QNv402snE48JATS+9++2VNVuASih8eKZPwYHCQwQWcLGDR6D6dN8LQINQqn/tk0NBQcJDBZk3/= +/ +XR4JCy6LpjwFBgcJDkPSpj0SCQcBBQYHCBxp/5UpCAEGBwgjxPiKHQkFBg5F/u2BFgQFBqDt//= // +4HMGAzPH/P/4zmN+3iWo569JX4wBAQESLjA2MGNjNzc0ZC1lMDI5LTQ5YzYtYWQ4My1hMzRkNj= Vm +OTZkOTBjZmY0MjQtNmFiNy00MzE3LTlkZjktYzcyNzY4YWViNzYyNTcuOSBtDTI4Ni4wODg5TE= xs +M0ENMjIgMjY4OS42MTNtMTMxLjUzNTczNjA4Mzk4NFM2MjQwNTg5NzctYThjNy00NTk3LWFjYT= Ut +Mzg0M2YzODhkODU5NDc4Njg4NTM4MDc0NDkzNDc3NjExOTI5MTc4MjM4IDQ0NS43NjA1ODk1OT= k2 +MDkgMjM1LjE3ODQwNV0gMzA1IDEzNDEyMjYxgICAj5+fn6+/z8/P39/fz8/Pv6+fn5+Pf39/np= 6e +q6urwsLCf39/nZ2d0dHRjo6OqqqqwcHBz8/Pra2tkJCQxMTEwMDAjY2Nw8PDrq6unJycv7+/w8= PD +zs7O19fXl5eXkJCQgYGBtbW10tLSxcXFubm5r6+vrKysoKCgl5eXkZGRvr6+sLCwqKiozc3Ngo= KC +i4uLvb29tLS0xsbGubm5sbGxm5ubvLy8xsbGurq609PTsrKymJiYkZGRg4ODx8fHoqKik5OTs7= Oz +hISEiYmJkpKSmpqa0NDQrKyso6OjhYWFpaWl1NTUmZmZkJCQnp6ehoaGmZmZhoaGkpKSkJCQ2d= nZ +1dXVysrKvb29h4eHmpqao6OjiIiInp6ey8vLoqKikZGR1tbWy8vLzMzMoaGhzc3NkJCQf39/mp= qa +wcHBwsLCiYmJurq6wsLCvb29hoaGhYWFtLS0oaGhpaWlxsbGmZmZo6OjsrKyoqKix8fHyMjIur= q6 +oqKi1dXVycnJgoKChISEjY2NjI2OjI2OkJCQnZ5/f3+dnZ2qqqqhoqOkpaanqKmqqaqtra1/f3= +0 +tLSrq83NzYqKirS1tre4ubS1tre4ubq7vL2+f39/wZycnMrLzM3Oz9DV1tfYkJCQyMfGxcTGxc= TB +wcG6urqpqanDw8O5ubmwsLC5m5ubq6urmpqanp6ef39/jY2NlpaVlZWampqUk5STkpGQf5mZmY= Vm +qCOaFeIhaoQkJSlJoQPjFYAhEAgKBIXjkBwI40jORQ8TwMBBymCRIRAUggFiMDAMBgXBoDAQDo= Nw +CMIwGEUhEEajLGVBagcNWc+APwQtXzfm4GmaWRghjJOEDv7gZrn+lPfGc0PKr8lVE1hsc/CEiw= Pk +XPRPEC2V+vuRB8fXyRrOfuFm6trnlMkz3kGDGMPbwITaFH5D7joCyy9YBvttgxKyO4Qk5I9ASU= 8C +PPFBHq6JjSZVYnqmxjubGO6B1jGxDwURwK0AGJJIwxTC4ZjNB45NE1rVPWdMvBna44ycSwvOOI= n3 +a9kc+/DIRNIpSzg7ogBthq2atESoBFIykcWrBAQqBHYWN4Tjj19wU6ATIEFJmjte5vS8aPVZwL= m0 +cP2G3A74QwBCxoRX0OPjAH9z4eQ+XzZFH1qaQcptAA7WbQPsX/U2gD4d3fVDL1WyPjcx+uAPzP= Kn +xQBCcPMqC15zcADW7nGAvSbYABXBvwF/jYBGXbGc+vDurPChregWZnk4YtqWcQKjPjCV5+J6G4= 1D +0NBbK+JzE3KW5ZilwXGkoNqgDdUjG+eVFaeAt9ti58qccI8vW04QS9vTUfJBFlCDMxDYCvhIZ7= L9 +w4/HAyTjTMpv3mVt4vrUPKo8M6iVnCVQ/FejkXiAsot77C4tp9oGygi1r/g4Upgu/TaI5rRoDF= RV +2hM9299gg4KxHlVT8oeEzoV2y3Jzf0MH7vHGchg0p/4tVw4Vz1TWK38o4YTldAoapEkPVhfl0h= Iq +n5pHy4K7IHFKLNKu9Qo+9wYxulOwQ3C7Oo3iqN2dL4iMe9S9tOA/2I2DobrWBtoNsVyxYNUf15= hZ +uSctZbXHqYZgHiXrABK6nHVgBvmNLmLB1E0MlKgmQq0N4oZ9ffjfIeiAS6QUSFQrl6AuUnFdWC= IY +0CjRPwhMBtGb5YqfXKZl+oj0cTjqtC1o1ZkFnAYhxXACBa35LvCodbuJI+VJwR6gKEqavDiWo7= +A +v0NfmY4ipU9n92CgPonJ92Cr8DY1yXOf/V77mU+b+1seDfttlpiS7IFpubLp0WaglkWWWJinV+= 5o +kY+Rfiv41OfP1J80H+oBUeW3hwdB/owMvfiw5+P+OYHJNmVyBb02FnL0+12ubk/XFVfJ4G9iIc= qF +oymFubb8chYpeKUQO5d0/M/VVpDZubJnbVC1o0QIQpDBsqlCDABc7VA08JUeWycL2a7bLHw4mX= rL +O7tdtTC09QSRsAXjUbizaCh0yy8b56fkeqsNgEKg6inDmN+rqyv1BmtKxMryuBZ1r08bAcZfoU= SV +wvxcIIF5mG+3F6w2zC8wq4J2yYRgqaNkzj2rL46USlcrNMoVpBcmm5J9B67EXAa061TqJNGVV5= /k +UmQLgl5tJD2/wVTG5UoCsJZ5ryBNud4k2iDIbJvW6l5Z6MGmvFRRz/LkSgBHyXNinkYIVqG1rk= K0 +i+f/K8gfAKp4tBnhe1YWAfbJWm2QatQT33fOub/jWX0wnKPHJduZbIRJdJhsigKgsNp3OA3blP= 3d +WWEmiHGavGBoM61XgJrZ/h3lQCu7BUFwuV6/jaSy+oB4rOVkCM1Avq0AMLps+Q5dn5yFI11R9Z= S0 +A+DBsdTBN3k9aTPl3lqm8c8BLkxir4Kg8uTKnDa89BVxWx65gnTOlSlAbsrbRUiBnDzXm8kGvV= Zj +Ps92tgva2vH+4hRGPy7X+5mdVlCX6tYpCqwiZHi4NXwXVP3m6XYhWvcxU3qg4vudhAlTv9lw15= dU +KROHEn0dtjz0lFFr5qaisguXitnbSqclPic/vlGkvTkqKoUilSsQbJYu+9Fyn8tWaNW75SfH8g= q2 +xGKR5PZULfNNAcpsFT8elb1+9qKVoyfdn30Iuizr77dZwXtF7MNmdvKYXH+sVGAru6iuvPLJAp= CO ++qQhY6/KeZbiySTtBQYiHM1MRDS2urrwU3APMSqa2VBXqRVZxRaBxlveqkB/35/f+x0qyQBbs+= Wx +YIW5qFmb90rwj8sNlfXo+ceuU8uY22O/+qF2by0fEdB0R6xIxnZtG3N1yxUsSIS4sSkfmvZt31= +u +QDi3EAyv7F3g7EOXSc9l315rRavrX7O75ffeXqcPV2zEe+fTnlhsGXizOJ6e0esUCVvLvZ4OyH= 5D +fUskia2qXo6DZKmnlds4N7nzRI9v2GUXFF0XcrBZE/8txwHi184y4zXLq36JLfuG5ayS/p1quZ= bH +I2VkZWFOvre4ZfDR9clpi/itqtTPdbUoZLMJYHNhtAmcXsSyyVN5zyH5DR267mN79O30di5rcA= Q8 +rcW/iH3VncoysmTUgJQcuErdYNfyS+Xo4SVCJYfzgmXjl15h7pyLILoGw9+1/BY+CQdr7sR0ju= GM +78ZtNmh1HJ/57AeXaRu3FNzJ1bTn2aJ05YBKoQNPxRVTQCV+QQsl1/WKxz/vG6IQFgW9i44rmh= O4 +dYkPSGm+yh0h/K2AfrwpCuBVmxJeTUk6Dv915Yg0xLLKJcKsnJfIjfrGrmaeR+XjLgJmnjdy8l= zJ +4nBefWtjEGZUSjw65q5VaO64gyZfcs6V83wc48WkIGGDxn7JC8QHoMP33IJX7uIWxFHz9Zo3TJ= d8 +uN5ByZBCjA222Pg4jycsUlnLbjsvxtfwWx/4HlWKV4WX71qCxz1dhSEzF46X3NXj2QxPUDRF0k= vs +vax2Mg7bwsyxlncSEk7k9jl+BX+sSAWWsEa85GNrJ20PdqNPCMew1GEvm6Pi8rqW+9i55ihamQ= bk +Op5KJkOvwK4JBmt4Y0nqQaI+aPk0GlOZrowSSVnWsawrYxwLbWto7yw5LLTsbdno5mVfMfCWsy= RR +ETI8zIKe8MCWtfSsatNI3npYuvHNHfrkHn8fQkfCvzbn5mvI8MBwsD/3Hl7hwTsdIekDQKAFk5= Qk +Z8QImKGYyMt5CiDoiT3raBOCglOIn0+iBghygsgYhKKeAgK8cH/xHC8kJOHe7LptDDUKRbld1q= jJ +xhHA6DM2mBpT2nL0EevNjCG5KgRQduCDJ7SJx5JJHMNjgHy8QhxK8OsP5SVWPbmTFLTmRuYA1q= 0k +l1UPwLbO8nuGHwcj/t0BeMXfAP6MxQSRv4/NYJCSz8yUL62j4V7zzJQmeV7PigBGZEH2LGbPPI= pU +CkWCxIcERdvCrwQgdz++mCW9O7FjvUEXn5aILSHdBcMI4qzIP8RS+UAf+i4vI3+2pQ=3D=3D + + + u8tGndtRhjJePGKVyP+2/dOFEFEdzcIDkuB8MW+Oo1BTD1ZuFN1rAAY4kVF8q1Fofd0TjGVnl= Foz +64B9jFj3WNI7MJKx0fZzEQf6iQq9hjCL6uFoaYC0F0R88AcrOi97QURfPZNUSiliWy9401nb8U= R5 +QEyMyJeXLtFJAVCGTS848nqK6AUhK00YJkKmMBGT3A5AOCElGuo1z/PUwcTBFsspd9g461Qwkf= v/ +EulWPGeumoW3RkwzMYZwCyMX0uIuhGDrPpbkEMfcOW/5AE0UnbWuAqkN524yL8cdzfMG12Qepl= Ae +axcGNxGiYHKnJ9nEehbY0zyPHak60GxKZBtqceuIrZiVuEgR1HFDM6hc7XYAgztUZH5faWcOqX= xd +FR7QZMJKxBQa3CXTRwSag/YcHyINEY9xgxmJ3fnYM+AavoqU83NHCcKO1f4oeEaa5y0IghAfXB= Ox +AIdAHL8Qjad5nnDgR6ZYCC/jYLlZMZTlRKG9I0/GuAQPVTwdhdWnryePsY+U4Q35pYJYFQBTHt= Bj +z0P6c/QeWl+gpqsnzt4LtS1VGmrFtzW+UY+I/YrmeZiagTSwHIASq/IPOU+dRH4NZZypeZ7OSS= GU +ez6BGl4Zv4vkdcmztAmpkGDGSC9Axxq9CUmoreGjgOZ5REYoOZDOH35NLX9PsMWbJHFH7LFsLu= rU +eaBM6ljyvCOzFtVVmOrPOEePuRWUN6HBs2UriCGZ4JM6wxeogywFS4DK6eJxydbZCt0jDjFEYz= bN +/eAbv1S6R6AGPETzPL3qn9mJkX0B9LuxBKO/JzsnvuFVYCIEmSNOWa89I4RfSpOwqZ3s0MCVYs= hF +F6C8XXSDMmfij1xUaL+bfhNt7isbZ27XXkXeiz+a5y1yAPo9lCO7e+9WJlwbgwRuuHxE/Z4R/r= 7o +dg0l1Jsp090H4kAhkc7RQ7F2UdDSblNDxycPA91XnGfS4rJxn+Z5FIPixkKngCrh+TVN5Orcz0= O+ +4lOCNmYVUeLmd0w4Ry9uUL9V63hjp/1icwJYdqw2BU8fztFbg1pKEsSSew77TT/tdqxae7HWJU= Nh +8NWFzaJXAkm+jwB4r+G3BNKpZzYoQY66Iz0h/SJmwXygPjb3MemQ5GwYlaw6Bi78jH2vAf7uuU= k/ +GK/BdbAnCQvU2npPcfl9erZkULye6fSqgGJmqkLZyEYlESLEsIzLpIBFOFBqa7zjYERFsWTwch= US +gZsD9c1iP09vP1SCykHoVuqBYx8o/oQ/QxPwDCghcrhWxS8xpO8D9ROXqlO2KgfeODaRg09EnZ= yE +LgGRQGCB5EgqUN6dNz/m6hlIJpyxBJKtu0tITHdkNk2baOafV1BIZLQk4Fvd+1vyy0gNvS0nbJ= VI +E/XkBfijcxJzHswmTrm7259ftREoUPvA0fPPglKHonvbPMFJoUmjJC03OhaUS6HhMZSbciSCBG= Kj +zqArUu5WjHpMCRU+tSykeOr1KfSepEUtRw6Z++9UR7jIWqsnS/zxrmKqteWZ0KqwOzvtoj3Jov= W0 +rIEKsSId7cnMXksD4BGGIG4VxBYNgsaHLQoWSYUFh4ctld9+WyZJBbM1EyYgWX9R39Ea0N0Zsb= aE +cvEb25MMpq9le4Jv1Z4U8nSnLdacex1Si9piqrz606l+9UCvQPjGCEvCmPsXJDX+gmKcwr/gC1= 12 +fupVBeUxACY2jy2QN+n//1fAxe5ka83QqyQWVuvBRub/VsotwVbVFYiviTGllFJKMl29gh8/Ew= OJ +AHkAeAD+h5/lFjGVsW9ev6AqMFDxEfu3kw0WRs1jZEV2o8vbBvN1EVn1857TOJL/0wv+rqomIA= 7H +GT7ugr+Iwq38XcdMDNmPpTNqCNMa6qMnvFRKStUvZjaG55H1WrVXJi1Bt86jU1FRcXFxAQEB8f= Dw +8Hg8IiIiIiIiJCQkJiYmHo+HhYWFhYUFBQXFg3+MtUrQF7UnIA5HGjWuz9+L1I2iQ8oYf7qho9= RW +5Zsf1M3+SClXfIs9SUwhdAxZ1ZaqZSlhJlLr///3yzne6ZVOxd/Ow4UOKktOI1t/aq6YLFnJ6R= PU +GABJqtnm8vici0HGsnKnfxqDBQ2SEr03i7qiX3lWJHnyqrkJjvP/fi7bxmGOv+Q9osDg+1xzeP= 5e +HJORfHi8pdGRc4C/HOO9KHfzPR5ftpbX3kTEcqlLoSa+1J0lldySczVFTjOXmq6fkAAM/c1U/W= az +xR37PJ3LPSrzOferapZ8vPMti8ro7O+KXAz69jHIaCOl1pYrZHiudgLIAAICGo1GA1EIZ0GDBQ= QN +DMWw4NCgGBAYCuEsUA7HYUGBgsNQDE4DAsKgEhIcBgMK4RRoNBAzBuXgOAA4Elr1+7/EE9tuZI= iR +WrLozKTl7XjymLRJMq1pjZbb3VF7dGjbn9xRJu0tL2pK1tt3uiWnGh41lonJxLrY/IfPL/8cS6= nH +Fr4aenKWfp3thM4EgWeocZohERGRpCCp0WLRBERAFEFGEUIIY5CdBxJAYGgIgiMEGINgHAlzCC= LE +EIEREiEhhggNQYiIiDyFdC0rtSY9AhNK+GeZscUK5RsQlZQ4tjydSbDGIGgsjZX9s9L2g76EOM= X/ +dTdEfCEd55SXIcGjnHLjzAjaeWt4FTDpHP8PVOrsfAPu2SHNiW/G+I/P+RquauDADaBLNjZArW= Sl +/RC7P+aIkbSdvSiGRVEAYMqoTvHl88BAP4IKROb9SCi+sJ3iwoycpga1w27C7hdtQzlNQPGFSl= la +7OXgu/0lab1kOzJg+sFGgPP6WkLxZXp1/Q3+9ovD0JkELZoBMrCGvzZ5im11rAtRrBnBne7fGH= ar +CUN3DFeQyP/X1UIXFknB3tGmeJrBVC87orVSG/D8j5A608Qdkai48PxfWwqOXHkAalqnzK8+Po= El +n4qdoRbhdKX0e5oB0+ACa+OUrp6ju2Z0LWrfNLqvcUhKrE7ZFv2kEQcpHj10FrJMBvM5BZoxSQ= 8U +jRuhz813Jo/iP9ALARwzcx4NgSUU1WMMxS0EWfJzSqgvAZjXjjnzaxfTBArq4y9+LSNc4dd1d9= xt +a9IKFNfvlaFjPAjyFuoE407tGGDopQFgr5hH75ymex8Nl2TG++QaSI5KZySun+g+qOUXiA4y7W= ue +UxlOB7SxGND1kE+9gG41yArrB3O/D9D7gR0AtPBoB9NsKL7NuCVm5sYIFpCOFkMaeWRkgXCMV0= BD +BtVcrSM2CkPrEdZoQRS+7jFWOOOdjj80raUcia9R/wZLfnL0hpN1AkdtxKEnd+Unj6xOjyq1r5= e6 +9ChKmGyp2dyvVyaFXK/LMoQjmXgb4F8N/pDZ/B0RVRdhDuo6Lc9fVT1ByEFJtdoTSJuRsQ3way= zj +xtDdKllAtiv4ROgDdauP3beWx8AfhK2ibE8KJBz3Hfdy5fx6HcYKaVkuFcyrm1CgtVau5fHC0J= i3 +glU5llwM4A/emS1jTLiJAS5Hv3qri8C2mwgJa9k3wuAPpYk5QGucJoY+8IfUlifZzy3Yzk0Qyr= J7 +24+XfY2qFWjKdNAmBvOYbJlspzWFbDlJEwNUz7pnrGWYeYVS1cMbcYHN1CDUspMDonFSJo39Db= Ft +YgB8sYeq3jxxVxaPv5bhAX8AvCB3sHgsgDI16CjgD4/x6jueW5ll8aBC1y2bzP6GlA5aS4M/2B= Sv +bKurZfTfEJDBBSv4Q7TTtRzl3TI0pEWnCS8Yp7W7F5wdjyNdY9F+Q7rI39UVj4WLAn842eZYPG= os ++zQx1EodwtgFGIBVunluAo6t5fQ4yVClgwBFMtsp0w8hFbpaxvBYQLrMJnpBN/qu3k4WXapkJr= aJ +oUmDEmeJAQ=3D=3D + + + diff --git a/Documentation/bpf/index.rst b/Documentation/bpf/index.rst index 1bc2c5c58bdb..1a8d372b6faf 100644 --- a/Documentation/bpf/index.rst +++ b/Documentation/bpf/index.rst @@ -24,6 +24,7 @@ that goes into great technical depth about the BPF Archit= ecture. maps bpf_prog_run classic_vs_extended.rst + bpf_iterators bpf_licensing test_debug other --=20 2.30.2