From b918d4b55febb5bddecacd3ea69d8724188fa12c Mon Sep 17 00:00:00 2001 From: zhanglianghy Date: Tue, 18 Jun 2019 09:23:50 +0800 Subject: [PATCH] =?UTF-8?q?Add=20aaa-12=20A=20=E6=8F=90=E4=BA=A4=E7=AC=AC?= =?UTF-8?q?=E4=B8=89=E6=96=B9=E5=BA=93=E4=BB=A5=E5=8F=8A=E5=A4=B4=E6=96=87?= =?UTF-8?q?=E4=BB=B6=20RCA=EF=BC=9A=20SOL=EF=BC=9A=20=E4=BF=AE=E6=94=B9?= =?UTF-8?q?=E4=BA=BA=EF=BC=9Azhangliang=20=E6=A3=80=E8=A7=86=E4=BA=BA?= =?UTF-8?q?=EF=BC=9Azhangliang?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Platform/common/rpc/ev.h | 854 ++++++++++++++++++++++++++++ Platform/thirdparty/x86_64/libev.so | Bin 0 -> 55736 bytes 2 files changed, 854 insertions(+) create mode 100755 Platform/common/rpc/ev.h create mode 100755 Platform/thirdparty/x86_64/libev.so diff --git a/Platform/common/rpc/ev.h b/Platform/common/rpc/ev.h new file mode 100755 index 000000000..38f62d82e --- /dev/null +++ b/Platform/common/rpc/ev.h @@ -0,0 +1,854 @@ +/* + * libev native API header + * + * Copyright (c) 2007,2008,2009,2010,2011,2012,2015 Marc Alexander Lehmann + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modifica- + * tion, 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 THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER- + * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO + * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE- + * CIAL, 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 OTH- + * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED + * OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Alternatively, the contents of this file may be used under the terms of + * the GNU General Public License ("GPL") version 2 or any later version, + * in which case the provisions of the GPL are applicable instead of + * the above. If you wish to allow the use of your version of this file + * only under the terms of the GPL and not to allow others to use your + * version of this file under the BSD license, indicate your decision + * by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL. If you do not delete the + * provisions above, a recipient may use your version of this file under + * either the BSD or the GPL. + */ + +#ifndef EV_H_ +#define EV_H_ + +#ifdef __cplusplus +# define EV_CPP(x) x +# if __cplusplus >= 201103L +# define EV_THROW noexcept +# else +# define EV_THROW throw () +# endif +#else +# define EV_CPP(x) +# define EV_THROW +#endif + +EV_CPP(extern "C" {) + +/*****************************************************************************/ + +/* pre-4.0 compatibility */ +#ifndef EV_COMPAT3 +# define EV_COMPAT3 1 +#endif + +#ifndef EV_FEATURES +# if defined __OPTIMIZE_SIZE__ +# define EV_FEATURES 0x7c +# else +# define EV_FEATURES 0x7f +# endif +#endif + +#define EV_FEATURE_CODE ((EV_FEATURES) & 1) +#define EV_FEATURE_DATA ((EV_FEATURES) & 2) +#define EV_FEATURE_CONFIG ((EV_FEATURES) & 4) +#define EV_FEATURE_API ((EV_FEATURES) & 8) +#define EV_FEATURE_WATCHERS ((EV_FEATURES) & 16) +#define EV_FEATURE_BACKENDS ((EV_FEATURES) & 32) +#define EV_FEATURE_OS ((EV_FEATURES) & 64) + +/* these priorities are inclusive, higher priorities will be invoked earlier */ +#ifndef EV_MINPRI +# define EV_MINPRI (EV_FEATURE_CONFIG ? -2 : 0) +#endif +#ifndef EV_MAXPRI +# define EV_MAXPRI (EV_FEATURE_CONFIG ? +2 : 0) +#endif + +#ifndef EV_MULTIPLICITY +# define EV_MULTIPLICITY EV_FEATURE_CONFIG +#endif + +#ifndef EV_PERIODIC_ENABLE +# define EV_PERIODIC_ENABLE EV_FEATURE_WATCHERS +#endif + +#ifndef EV_STAT_ENABLE +# define EV_STAT_ENABLE EV_FEATURE_WATCHERS +#endif + +#ifndef EV_PREPARE_ENABLE +# define EV_PREPARE_ENABLE EV_FEATURE_WATCHERS +#endif + +#ifndef EV_CHECK_ENABLE +# define EV_CHECK_ENABLE EV_FEATURE_WATCHERS +#endif + +#ifndef EV_IDLE_ENABLE +# define EV_IDLE_ENABLE EV_FEATURE_WATCHERS +#endif + +#ifndef EV_FORK_ENABLE +# define EV_FORK_ENABLE EV_FEATURE_WATCHERS +#endif + +#ifndef EV_CLEANUP_ENABLE +# define EV_CLEANUP_ENABLE EV_FEATURE_WATCHERS +#endif + +#ifndef EV_SIGNAL_ENABLE +# define EV_SIGNAL_ENABLE EV_FEATURE_WATCHERS +#endif + +#ifndef EV_CHILD_ENABLE +# ifdef _WIN32 +# define EV_CHILD_ENABLE 0 +# else +# define EV_CHILD_ENABLE EV_FEATURE_WATCHERS +#endif +#endif + +#ifndef EV_ASYNC_ENABLE +# define EV_ASYNC_ENABLE EV_FEATURE_WATCHERS +#endif + +#ifndef EV_EMBED_ENABLE +# define EV_EMBED_ENABLE EV_FEATURE_WATCHERS +#endif + +#ifndef EV_WALK_ENABLE +# define EV_WALK_ENABLE 0 /* not yet */ +#endif + +/*****************************************************************************/ + +#if EV_CHILD_ENABLE && !EV_SIGNAL_ENABLE +# undef EV_SIGNAL_ENABLE +# define EV_SIGNAL_ENABLE 1 +#endif + +/*****************************************************************************/ + +typedef double ev_tstamp; + +#include /* for memmove */ + +#ifndef EV_ATOMIC_T +# include +# define EV_ATOMIC_T sig_atomic_t volatile +#endif + +#if EV_STAT_ENABLE +# ifdef _WIN32 +# include +# include +# endif +# include +#endif + +/* support multiple event loops? */ +#if EV_MULTIPLICITY +struct ev_loop; +# define EV_P struct ev_loop *loop /* a loop as sole parameter in a declaration */ +# define EV_P_ EV_P, /* a loop as first of multiple parameters */ +# define EV_A loop /* a loop as sole argument to a function call */ +# define EV_A_ EV_A, /* a loop as first of multiple arguments */ +# define EV_DEFAULT_UC ev_default_loop_uc_ () /* the default loop, if initialised, as sole arg */ +# define EV_DEFAULT_UC_ EV_DEFAULT_UC, /* the default loop as first of multiple arguments */ +# define EV_DEFAULT ev_default_loop (0) /* the default loop as sole arg */ +# define EV_DEFAULT_ EV_DEFAULT, /* the default loop as first of multiple arguments */ +#else +# define EV_P void +# define EV_P_ +# define EV_A +# define EV_A_ +# define EV_DEFAULT +# define EV_DEFAULT_ +# define EV_DEFAULT_UC +# define EV_DEFAULT_UC_ +# undef EV_EMBED_ENABLE +#endif + +/* EV_INLINE is used for functions in header files */ +#if __STDC_VERSION__ >= 199901L || __GNUC__ >= 3 +# define EV_INLINE static inline +#else +# define EV_INLINE static +#endif + +#ifdef EV_API_STATIC +# define EV_API_DECL static +#else +# define EV_API_DECL extern +#endif + +/* EV_PROTOTYPES can be used to switch of prototype declarations */ +#ifndef EV_PROTOTYPES +# define EV_PROTOTYPES 1 +#endif + +/*****************************************************************************/ + +#define EV_VERSION_MAJOR 4 +#define EV_VERSION_MINOR 22 + +/* eventmask, revents, events... */ +enum { + EV_UNDEF = (int)0xFFFFFFFF, /* guaranteed to be invalid */ + EV_NONE = 0x00, /* no events */ + EV_READ = 0x01, /* ev_io detected read will not block */ + EV_WRITE = 0x02, /* ev_io detected write will not block */ + EV__IOFDSET = 0x80, /* internal use only */ + EV_IO = EV_READ, /* alias for type-detection */ + EV_TIMER = 0x00000100, /* timer timed out */ +#if EV_COMPAT3 + EV_TIMEOUT = EV_TIMER, /* pre 4.0 API compatibility */ +#endif + EV_PERIODIC = 0x00000200, /* periodic timer timed out */ + EV_SIGNAL = 0x00000400, /* signal was received */ + EV_CHILD = 0x00000800, /* child/pid had status change */ + EV_STAT = 0x00001000, /* stat data changed */ + EV_IDLE = 0x00002000, /* event loop is idling */ + EV_PREPARE = 0x00004000, /* event loop about to poll */ + EV_CHECK = 0x00008000, /* event loop finished poll */ + EV_EMBED = 0x00010000, /* embedded event loop needs sweep */ + EV_FORK = 0x00020000, /* event loop resumed in child */ + EV_CLEANUP = 0x00040000, /* event loop resumed in child */ + EV_ASYNC = 0x00080000, /* async intra-loop signal */ + EV_CUSTOM = 0x01000000, /* for use by user code */ + EV_ERROR = (int)0x80000000 /* sent when an error occurs */ +}; + +/* can be used to add custom fields to all watchers, while losing binary compatibility */ +#ifndef EV_COMMON +# define EV_COMMON void *data; +#endif + +#ifndef EV_CB_DECLARE +# define EV_CB_DECLARE(type) void (*cb)(EV_P_ struct type *w, int revents); +#endif +#ifndef EV_CB_INVOKE +# define EV_CB_INVOKE(watcher,revents) (watcher)->cb (EV_A_ (watcher), (revents)) +#endif + +/* not official, do not use */ +#define EV_CB(type,name) void name (EV_P_ struct ev_ ## type *w, int revents) + +/* + * struct member types: + * private: you may look at them, but not change them, + * and they might not mean anything to you. + * ro: can be read anytime, but only changed when the watcher isn't active. + * rw: can be read and modified anytime, even when the watcher is active. + * + * some internal details that might be helpful for debugging: + * + * active is either 0, which means the watcher is not active, + * or the array index of the watcher (periodics, timers) + * or the array index + 1 (most other watchers) + * or simply 1 for watchers that aren't in some array. + * pending is either 0, in which case the watcher isn't, + * or the array index + 1 in the pendings array. + */ + +#if EV_MINPRI == EV_MAXPRI +# define EV_DECL_PRIORITY +#elif !defined (EV_DECL_PRIORITY) +# define EV_DECL_PRIORITY int priority; +#endif + +/* shared by all watchers */ +#define EV_WATCHER(type) \ + int active; /* private */ \ + int pending; /* private */ \ + EV_DECL_PRIORITY /* private */ \ + EV_COMMON /* rw */ \ + EV_CB_DECLARE (type) /* private */ + +#define EV_WATCHER_LIST(type) \ + EV_WATCHER (type) \ + struct ev_watcher_list *next; /* private */ + +#define EV_WATCHER_TIME(type) \ + EV_WATCHER (type) \ + ev_tstamp at; /* private */ + +/* base class, nothing to see here unless you subclass */ +typedef struct ev_watcher +{ + EV_WATCHER (ev_watcher) +} ev_watcher; + +/* base class, nothing to see here unless you subclass */ +typedef struct ev_watcher_list +{ + EV_WATCHER_LIST (ev_watcher_list) +} ev_watcher_list; + +/* base class, nothing to see here unless you subclass */ +typedef struct ev_watcher_time +{ + EV_WATCHER_TIME (ev_watcher_time) +} ev_watcher_time; + +/* invoked when fd is either EV_READable or EV_WRITEable */ +/* revent EV_READ, EV_WRITE */ +typedef struct ev_io +{ + EV_WATCHER_LIST (ev_io) + + int fd; /* ro */ + int events; /* ro */ +} ev_io; + +/* invoked after a specific time, repeatable (based on monotonic clock) */ +/* revent EV_TIMEOUT */ +typedef struct ev_timer +{ + EV_WATCHER_TIME (ev_timer) + + ev_tstamp repeat; /* rw */ +} ev_timer; + +/* invoked at some specific time, possibly repeating at regular intervals (based on UTC) */ +/* revent EV_PERIODIC */ +typedef struct ev_periodic +{ + EV_WATCHER_TIME (ev_periodic) + + ev_tstamp offset; /* rw */ + ev_tstamp interval; /* rw */ + ev_tstamp (*reschedule_cb)(struct ev_periodic *w, ev_tstamp now) EV_THROW; /* rw */ +} ev_periodic; + +/* invoked when the given signal has been received */ +/* revent EV_SIGNAL */ +typedef struct ev_signal +{ + EV_WATCHER_LIST (ev_signal) + + int signum; /* ro */ +} ev_signal; + +/* invoked when sigchld is received and waitpid indicates the given pid */ +/* revent EV_CHILD */ +/* does not support priorities */ +typedef struct ev_child +{ + EV_WATCHER_LIST (ev_child) + + int flags; /* private */ + int pid; /* ro */ + int rpid; /* rw, holds the received pid */ + int rstatus; /* rw, holds the exit status, use the macros from sys/wait.h */ +} ev_child; + +#if EV_STAT_ENABLE +/* st_nlink = 0 means missing file or other error */ +# ifdef _WIN32 +typedef struct _stati64 ev_statdata; +# else +typedef struct stat ev_statdata; +# endif + +/* invoked each time the stat data changes for a given path */ +/* revent EV_STAT */ +typedef struct ev_stat +{ + EV_WATCHER_LIST (ev_stat) + + ev_timer timer; /* private */ + ev_tstamp interval; /* ro */ + const char *path; /* ro */ + ev_statdata prev; /* ro */ + ev_statdata attr; /* ro */ + + int wd; /* wd for inotify, fd for kqueue */ +} ev_stat; +#endif + +#if EV_IDLE_ENABLE +/* invoked when the nothing else needs to be done, keeps the process from blocking */ +/* revent EV_IDLE */ +typedef struct ev_idle +{ + EV_WATCHER (ev_idle) +} ev_idle; +#endif + +/* invoked for each run of the mainloop, just before the blocking call */ +/* you can still change events in any way you like */ +/* revent EV_PREPARE */ +typedef struct ev_prepare +{ + EV_WATCHER (ev_prepare) +} ev_prepare; + +/* invoked for each run of the mainloop, just after the blocking call */ +/* revent EV_CHECK */ +typedef struct ev_check +{ + EV_WATCHER (ev_check) +} ev_check; + +#if EV_FORK_ENABLE +/* the callback gets invoked before check in the child process when a fork was detected */ +/* revent EV_FORK */ +typedef struct ev_fork +{ + EV_WATCHER (ev_fork) +} ev_fork; +#endif + +#if EV_CLEANUP_ENABLE +/* is invoked just before the loop gets destroyed */ +/* revent EV_CLEANUP */ +typedef struct ev_cleanup +{ + EV_WATCHER (ev_cleanup) +} ev_cleanup; +#endif + +#if EV_EMBED_ENABLE +/* used to embed an event loop inside another */ +/* the callback gets invoked when the event loop has handled events, and can be 0 */ +typedef struct ev_embed +{ + EV_WATCHER (ev_embed) + + struct ev_loop *other; /* ro */ + ev_io io; /* private */ + ev_prepare prepare; /* private */ + ev_check check; /* unused */ + ev_timer timer; /* unused */ + ev_periodic periodic; /* unused */ + ev_idle idle; /* unused */ + ev_fork fork; /* private */ +#if EV_CLEANUP_ENABLE + ev_cleanup cleanup; /* unused */ +#endif +} ev_embed; +#endif + +#if EV_ASYNC_ENABLE +/* invoked when somebody calls ev_async_send on the watcher */ +/* revent EV_ASYNC */ +typedef struct ev_async +{ + EV_WATCHER (ev_async) + + EV_ATOMIC_T sent; /* private */ +} ev_async; + +# define ev_async_pending(w) (+(w)->sent) +#endif + +/* the presence of this union forces similar struct layout */ +union ev_any_watcher +{ + struct ev_watcher w; + struct ev_watcher_list wl; + + struct ev_io io; + struct ev_timer timer; + struct ev_periodic periodic; + struct ev_signal signal; + struct ev_child child; +#if EV_STAT_ENABLE + struct ev_stat stat; +#endif +#if EV_IDLE_ENABLE + struct ev_idle idle; +#endif + struct ev_prepare prepare; + struct ev_check check; +#if EV_FORK_ENABLE + struct ev_fork fork; +#endif +#if EV_CLEANUP_ENABLE + struct ev_cleanup cleanup; +#endif +#if EV_EMBED_ENABLE + struct ev_embed embed; +#endif +#if EV_ASYNC_ENABLE + struct ev_async async; +#endif +}; + +/* flag bits for ev_default_loop and ev_loop_new */ +enum { + /* the default */ + EVFLAG_AUTO = 0x00000000U, /* not quite a mask */ + /* flag bits */ + EVFLAG_NOENV = 0x01000000U, /* do NOT consult environment */ + EVFLAG_FORKCHECK = 0x02000000U, /* check for a fork in each iteration */ + /* debugging/feature disable */ + EVFLAG_NOINOTIFY = 0x00100000U, /* do not attempt to use inotify */ +#if EV_COMPAT3 + EVFLAG_NOSIGFD = 0, /* compatibility to pre-3.9 */ +#endif + EVFLAG_SIGNALFD = 0x00200000U, /* attempt to use signalfd */ + EVFLAG_NOSIGMASK = 0x00400000U /* avoid modifying the signal mask */ +}; + +/* method bits to be ored together */ +enum { + EVBACKEND_SELECT = 0x00000001U, /* about anywhere */ + EVBACKEND_POLL = 0x00000002U, /* !win */ + EVBACKEND_EPOLL = 0x00000004U, /* linux */ + EVBACKEND_KQUEUE = 0x00000008U, /* bsd */ + EVBACKEND_DEVPOLL = 0x00000010U, /* solaris 8 */ /* NYI */ + EVBACKEND_PORT = 0x00000020U, /* solaris 10 */ + EVBACKEND_ALL = 0x0000003FU, /* all known backends */ + EVBACKEND_MASK = 0x0000FFFFU /* all future backends */ +}; + +#if EV_PROTOTYPES +EV_API_DECL int ev_version_major (void) EV_THROW; +EV_API_DECL int ev_version_minor (void) EV_THROW; + +EV_API_DECL unsigned int ev_supported_backends (void) EV_THROW; +EV_API_DECL unsigned int ev_recommended_backends (void) EV_THROW; +EV_API_DECL unsigned int ev_embeddable_backends (void) EV_THROW; + +EV_API_DECL ev_tstamp ev_time (void) EV_THROW; +EV_API_DECL void ev_sleep (ev_tstamp delay) EV_THROW; /* sleep for a while */ + +/* Sets the allocation function to use, works like realloc. + * It is used to allocate and free memory. + * If it returns zero when memory needs to be allocated, the library might abort + * or take some potentially destructive action. + * The default is your system realloc function. + */ +EV_API_DECL void ev_set_allocator (void *(*cb)(void *ptr, long size) EV_THROW) EV_THROW; + +/* set the callback function to call on a + * retryable syscall error + * (such as failed select, poll, epoll_wait) + */ +EV_API_DECL void ev_set_syserr_cb (void (*cb)(const char *msg) EV_THROW) EV_THROW; + +#if EV_MULTIPLICITY + +/* the default loop is the only one that handles signals and child watchers */ +/* you can call this as often as you like */ +EV_API_DECL struct ev_loop *ev_default_loop (unsigned int flags EV_CPP (= 0)) EV_THROW; + +#ifdef EV_API_STATIC +EV_API_DECL struct ev_loop *ev_default_loop_ptr; +#endif + +EV_INLINE struct ev_loop * +ev_default_loop_uc_ (void) EV_THROW +{ + extern struct ev_loop *ev_default_loop_ptr; + + return ev_default_loop_ptr; +} + +EV_INLINE int +ev_is_default_loop (EV_P) EV_THROW +{ + return EV_A == EV_DEFAULT_UC; +} + +/* create and destroy alternative loops that don't handle signals */ +EV_API_DECL struct ev_loop *ev_loop_new (unsigned int flags EV_CPP (= 0)) EV_THROW; + +EV_API_DECL ev_tstamp ev_now (EV_P) EV_THROW; /* time w.r.t. timers and the eventloop, updated after each poll */ + +#else + +EV_API_DECL int ev_default_loop (unsigned int flags EV_CPP (= 0)) EV_THROW; /* returns true when successful */ + +EV_API_DECL ev_tstamp ev_rt_now; + +EV_INLINE ev_tstamp +ev_now (void) EV_THROW +{ + return ev_rt_now; +} + +/* looks weird, but ev_is_default_loop (EV_A) still works if this exists */ +EV_INLINE int +ev_is_default_loop (void) EV_THROW +{ + return 1; +} + +#endif /* multiplicity */ + +/* destroy event loops, also works for the default loop */ +EV_API_DECL void ev_loop_destroy (EV_P); + +/* this needs to be called after fork, to duplicate the loop */ +/* when you want to re-use it in the child */ +/* you can call it in either the parent or the child */ +/* you can actually call it at any time, anywhere :) */ +EV_API_DECL void ev_loop_fork (EV_P) EV_THROW; + +EV_API_DECL unsigned int ev_backend (EV_P) EV_THROW; /* backend in use by loop */ + +EV_API_DECL void ev_now_update (EV_P) EV_THROW; /* update event loop time */ + +#if EV_WALK_ENABLE +/* walk (almost) all watchers in the loop of a given type, invoking the */ +/* callback on every such watcher. The callback might stop the watcher, */ +/* but do nothing else with the loop */ +EV_API_DECL void ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) EV_THROW; +#endif + +#endif /* prototypes */ + +/* ev_run flags values */ +enum { + EVRUN_NOWAIT = 1, /* do not block/wait */ + EVRUN_ONCE = 2 /* block *once* only */ +}; + +/* ev_break how values */ +enum { + EVBREAK_CANCEL = 0, /* undo unloop */ + EVBREAK_ONE = 1, /* unloop once */ + EVBREAK_ALL = 2 /* unloop all loops */ +}; + +#if EV_PROTOTYPES +EV_API_DECL int ev_run (EV_P_ int flags EV_CPP (= 0)); +EV_API_DECL void ev_break (EV_P_ int how EV_CPP (= EVBREAK_ONE)) EV_THROW; /* break out of the loop */ + +/* + * ref/unref can be used to add or remove a refcount on the mainloop. every watcher + * keeps one reference. if you have a long-running watcher you never unregister that + * should not keep ev_loop from running, unref() after starting, and ref() before stopping. + */ +EV_API_DECL void ev_ref (EV_P) EV_THROW; +EV_API_DECL void ev_unref (EV_P) EV_THROW; + +/* + * convenience function, wait for a single event, without registering an event watcher + * if timeout is < 0, do wait indefinitely + */ +EV_API_DECL void ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg) EV_THROW; + +# if EV_FEATURE_API +EV_API_DECL unsigned int ev_iteration (EV_P) EV_THROW; /* number of loop iterations */ +EV_API_DECL unsigned int ev_depth (EV_P) EV_THROW; /* #ev_loop enters - #ev_loop leaves */ +EV_API_DECL void ev_verify (EV_P) EV_THROW; /* abort if loop data corrupted */ + +EV_API_DECL void ev_set_io_collect_interval (EV_P_ ev_tstamp interval) EV_THROW; /* sleep at least this time, default 0 */ +EV_API_DECL void ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) EV_THROW; /* sleep at least this time, default 0 */ + +/* advanced stuff for threading etc. support, see docs */ +EV_API_DECL void ev_set_userdata (EV_P_ void *data) EV_THROW; +EV_API_DECL void *ev_userdata (EV_P) EV_THROW; +typedef void (*ev_loop_callback)(EV_P); +EV_API_DECL void ev_set_invoke_pending_cb (EV_P_ ev_loop_callback invoke_pending_cb) EV_THROW; +/* C++ doesn't allow the use of the ev_loop_callback typedef here, so we need to spell it out */ +EV_API_DECL void ev_set_loop_release_cb (EV_P_ void (*release)(EV_P) EV_THROW, void (*acquire)(EV_P) EV_THROW) EV_THROW; + +EV_API_DECL unsigned int ev_pending_count (EV_P) EV_THROW; /* number of pending events, if any */ +EV_API_DECL void ev_invoke_pending (EV_P); /* invoke all pending watchers */ + +/* + * stop/start the timer handling. + */ +EV_API_DECL void ev_suspend (EV_P) EV_THROW; +EV_API_DECL void ev_resume (EV_P) EV_THROW; +#endif + +#endif + +/* these may evaluate ev multiple times, and the other arguments at most once */ +/* either use ev_init + ev_TYPE_set, or the ev_TYPE_init macro, below, to first initialise a watcher */ +#define ev_init(ev,cb_) do { \ + ((ev_watcher *)(void *)(ev))->active = \ + ((ev_watcher *)(void *)(ev))->pending = 0; \ + ev_set_priority ((ev), 0); \ + ev_set_cb ((ev), cb_); \ +} while (0) + +#define ev_io_set(ev,fd_,events_) do { (ev)->fd = (fd_); (ev)->events = (events_) | EV__IOFDSET; } while (0) +#define ev_timer_set(ev,after_,repeat_) do { ((ev_watcher_time *)(ev))->at = (after_); (ev)->repeat = (repeat_); } while (0) +#define ev_periodic_set(ev,ofs_,ival_,rcb_) do { (ev)->offset = (ofs_); (ev)->interval = (ival_); (ev)->reschedule_cb = (rcb_); } while (0) +#define ev_signal_set(ev,signum_) do { (ev)->signum = (signum_); } while (0) +#define ev_child_set(ev,pid_,trace_) do { (ev)->pid = (pid_); (ev)->flags = !!(trace_); } while (0) +#define ev_stat_set(ev,path_,interval_) do { (ev)->path = (path_); (ev)->interval = (interval_); (ev)->wd = -2; } while (0) +#define ev_idle_set(ev) /* nop, yes, this is a serious in-joke */ +#define ev_prepare_set(ev) /* nop, yes, this is a serious in-joke */ +#define ev_check_set(ev) /* nop, yes, this is a serious in-joke */ +#define ev_embed_set(ev,other_) do { (ev)->other = (other_); } while (0) +#define ev_fork_set(ev) /* nop, yes, this is a serious in-joke */ +#define ev_cleanup_set(ev) /* nop, yes, this is a serious in-joke */ +#define ev_async_set(ev) /* nop, yes, this is a serious in-joke */ + +#define ev_io_init(ev,cb,fd,events) do { ev_init ((ev), (cb)); ev_io_set ((ev),(fd),(events)); } while (0) +#define ev_timer_init(ev,cb,after,repeat) do { ev_init ((ev), (cb)); ev_timer_set ((ev),(after),(repeat)); } while (0) +#define ev_periodic_init(ev,cb,ofs,ival,rcb) do { ev_init ((ev), (cb)); ev_periodic_set ((ev),(ofs),(ival),(rcb)); } while (0) +#define ev_signal_init(ev,cb,signum) do { ev_init ((ev), (cb)); ev_signal_set ((ev), (signum)); } while (0) +#define ev_child_init(ev,cb,pid,trace) do { ev_init ((ev), (cb)); ev_child_set ((ev),(pid),(trace)); } while (0) +#define ev_stat_init(ev,cb,path,interval) do { ev_init ((ev), (cb)); ev_stat_set ((ev),(path),(interval)); } while (0) +#define ev_idle_init(ev,cb) do { ev_init ((ev), (cb)); ev_idle_set ((ev)); } while (0) +#define ev_prepare_init(ev,cb) do { ev_init ((ev), (cb)); ev_prepare_set ((ev)); } while (0) +#define ev_check_init(ev,cb) do { ev_init ((ev), (cb)); ev_check_set ((ev)); } while (0) +#define ev_embed_init(ev,cb,other) do { ev_init ((ev), (cb)); ev_embed_set ((ev),(other)); } while (0) +#define ev_fork_init(ev,cb) do { ev_init ((ev), (cb)); ev_fork_set ((ev)); } while (0) +#define ev_cleanup_init(ev,cb) do { ev_init ((ev), (cb)); ev_cleanup_set ((ev)); } while (0) +#define ev_async_init(ev,cb) do { ev_init ((ev), (cb)); ev_async_set ((ev)); } while (0) + +#define ev_is_pending(ev) (0 + ((ev_watcher *)(void *)(ev))->pending) /* ro, true when watcher is waiting for callback invocation */ +#define ev_is_active(ev) (0 + ((ev_watcher *)(void *)(ev))->active) /* ro, true when the watcher has been started */ + +#define ev_cb_(ev) (ev)->cb /* rw */ +#define ev_cb(ev) (memmove (&ev_cb_ (ev), &((ev_watcher *)(ev))->cb, sizeof (ev_cb_ (ev))), (ev)->cb) + +#if EV_MINPRI == EV_MAXPRI +# define ev_priority(ev) ((ev), EV_MINPRI) +# define ev_set_priority(ev,pri) ((ev), (pri)) +#else +# define ev_priority(ev) (+(((ev_watcher *)(void *)(ev))->priority)) +# define ev_set_priority(ev,pri) ( (ev_watcher *)(void *)(ev))->priority = (pri) +#endif + +#define ev_periodic_at(ev) (+((ev_watcher_time *)(ev))->at) + +#ifndef ev_set_cb +# define ev_set_cb(ev,cb_) (ev_cb_ (ev) = (cb_), memmove (&((ev_watcher *)(ev))->cb, &ev_cb_ (ev), sizeof (ev_cb_ (ev)))) +#endif + +/* stopping (enabling, adding) a watcher does nothing if it is already running */ +/* stopping (disabling, deleting) a watcher does nothing unless it's already running */ +#if EV_PROTOTYPES + +/* feeds an event into a watcher as if the event actually occurred */ +/* accepts any ev_watcher type */ +EV_API_DECL void ev_feed_event (EV_P_ void *w, int revents) EV_THROW; +EV_API_DECL void ev_feed_fd_event (EV_P_ int fd, int revents) EV_THROW; +#if EV_SIGNAL_ENABLE +EV_API_DECL void ev_feed_signal (int signum) EV_THROW; +EV_API_DECL void ev_feed_signal_event (EV_P_ int signum) EV_THROW; +#endif +EV_API_DECL void ev_invoke (EV_P_ void *w, int revents); +EV_API_DECL int ev_clear_pending (EV_P_ void *w) EV_THROW; + +EV_API_DECL void ev_io_start (EV_P_ ev_io *w) EV_THROW; +EV_API_DECL void ev_io_stop (EV_P_ ev_io *w) EV_THROW; + +EV_API_DECL void ev_timer_start (EV_P_ ev_timer *w) EV_THROW; +EV_API_DECL void ev_timer_stop (EV_P_ ev_timer *w) EV_THROW; +/* stops if active and no repeat, restarts if active and repeating, starts if inactive and repeating */ +EV_API_DECL void ev_timer_again (EV_P_ ev_timer *w) EV_THROW; +/* return remaining time */ +EV_API_DECL ev_tstamp ev_timer_remaining (EV_P_ ev_timer *w) EV_THROW; + +#if EV_PERIODIC_ENABLE +EV_API_DECL void ev_periodic_start (EV_P_ ev_periodic *w) EV_THROW; +EV_API_DECL void ev_periodic_stop (EV_P_ ev_periodic *w) EV_THROW; +EV_API_DECL void ev_periodic_again (EV_P_ ev_periodic *w) EV_THROW; +#endif + +/* only supported in the default loop */ +#if EV_SIGNAL_ENABLE +EV_API_DECL void ev_signal_start (EV_P_ ev_signal *w) EV_THROW; +EV_API_DECL void ev_signal_stop (EV_P_ ev_signal *w) EV_THROW; +#endif + +/* only supported in the default loop */ +# if EV_CHILD_ENABLE +EV_API_DECL void ev_child_start (EV_P_ ev_child *w) EV_THROW; +EV_API_DECL void ev_child_stop (EV_P_ ev_child *w) EV_THROW; +# endif + +# if EV_STAT_ENABLE +EV_API_DECL void ev_stat_start (EV_P_ ev_stat *w) EV_THROW; +EV_API_DECL void ev_stat_stop (EV_P_ ev_stat *w) EV_THROW; +EV_API_DECL void ev_stat_stat (EV_P_ ev_stat *w) EV_THROW; +# endif + +# if EV_IDLE_ENABLE +EV_API_DECL void ev_idle_start (EV_P_ ev_idle *w) EV_THROW; +EV_API_DECL void ev_idle_stop (EV_P_ ev_idle *w) EV_THROW; +# endif + +#if EV_PREPARE_ENABLE +EV_API_DECL void ev_prepare_start (EV_P_ ev_prepare *w) EV_THROW; +EV_API_DECL void ev_prepare_stop (EV_P_ ev_prepare *w) EV_THROW; +#endif + +#if EV_CHECK_ENABLE +EV_API_DECL void ev_check_start (EV_P_ ev_check *w) EV_THROW; +EV_API_DECL void ev_check_stop (EV_P_ ev_check *w) EV_THROW; +#endif + +# if EV_FORK_ENABLE +EV_API_DECL void ev_fork_start (EV_P_ ev_fork *w) EV_THROW; +EV_API_DECL void ev_fork_stop (EV_P_ ev_fork *w) EV_THROW; +# endif + +# if EV_CLEANUP_ENABLE +EV_API_DECL void ev_cleanup_start (EV_P_ ev_cleanup *w) EV_THROW; +EV_API_DECL void ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_THROW; +# endif + +# if EV_EMBED_ENABLE +/* only supported when loop to be embedded is in fact embeddable */ +EV_API_DECL void ev_embed_start (EV_P_ ev_embed *w) EV_THROW; +EV_API_DECL void ev_embed_stop (EV_P_ ev_embed *w) EV_THROW; +EV_API_DECL void ev_embed_sweep (EV_P_ ev_embed *w) EV_THROW; +# endif + +# if EV_ASYNC_ENABLE +EV_API_DECL void ev_async_start (EV_P_ ev_async *w) EV_THROW; +EV_API_DECL void ev_async_stop (EV_P_ ev_async *w) EV_THROW; +EV_API_DECL void ev_async_send (EV_P_ ev_async *w) EV_THROW; +# endif + +#if EV_COMPAT3 + #define EVLOOP_NONBLOCK EVRUN_NOWAIT + #define EVLOOP_ONESHOT EVRUN_ONCE + #define EVUNLOOP_CANCEL EVBREAK_CANCEL + #define EVUNLOOP_ONE EVBREAK_ONE + #define EVUNLOOP_ALL EVBREAK_ALL + #if EV_PROTOTYPES + EV_INLINE void ev_loop (EV_P_ int flags) { ev_run (EV_A_ flags); } + EV_INLINE void ev_unloop (EV_P_ int how ) { ev_break (EV_A_ how ); } + EV_INLINE void ev_default_destroy (void) { ev_loop_destroy (EV_DEFAULT); } + EV_INLINE void ev_default_fork (void) { ev_loop_fork (EV_DEFAULT); } + #if EV_FEATURE_API + EV_INLINE unsigned int ev_loop_count (EV_P) { return ev_iteration (EV_A); } + EV_INLINE unsigned int ev_loop_depth (EV_P) { return ev_depth (EV_A); } + EV_INLINE void ev_loop_verify (EV_P) { ev_verify (EV_A); } + #endif + #endif +#else + typedef struct ev_loop ev_loop; +#endif + +#endif + +EV_CPP(}) + +#endif + diff --git a/Platform/thirdparty/x86_64/libev.so b/Platform/thirdparty/x86_64/libev.so new file mode 100755 index 0000000000000000000000000000000000000000..f2f9edf5e4396db8f60c00066fab2ca92a4be677 GIT binary patch literal 55736 zcmdqKe|%KM)jxidY;c3%4GM@A>qQq0ikK)UX#}%m19x@7NI+1)5H=e~4M|LPLr{d^ zW(n8pYAhhMwUwu})>f;uR#8yNFId2;0e^s66@MUiT@Zu{5rO@_&&=G-4Up$)pU>y} z$M<`AZSI{jXU?2CbLPyMGjlIX@;&2|laeI!N|DA&l&TuWA-N)>bEkN~Ems;XorAv@ zOFv<_sa;uTJiWJtgUq`mDGWe$^un*>EtbSxVGrirZsYI*ncvNF$w*Q;LzFW_IrF|p zG{wBzMR6iWzpWzw^t(ggnRmjat6;Ccgr2ATnI+G-HwZ-YZkD?p<%rLJ_evLtlSO?! z$t9BnfXlp#=CHQ)2RsG836rKuEuB|h`N5ITqUZMevHqR6N`HFd`Kkp}t{A_u_)&em z@sk?t$(Ku+=}VR7-m`1%_9@B9ij;f4v^RbFgN`SXr1UhYUb0KMy^|)}9rez%B*~t- zMoLPx*^~RBG&T2^Nz!o1*8hC_+T7{OhuajX-|TZr`k#|D+$IfHT;r0Jl#%H!DP?WC z-7Yz$jC579O_(U<<~9xKlb%Gp%;%`ViX}Ih7h4E_=FuFa4 z-!Jf6f!`|p=z1K#U*h*G{CRV?F{;2TdiWj%cNlp6GlAS{?I5?<%)~`Rle8m0pm;A0~a_Wf&N8?)uN}jBl`QzC4 zYd2i9_On5%`eyBrZOhtouKRw;c?(Bnd>5TpGG4v3;;o-N=*oT8J?+7Db+?~5|2OTv zxAOAe-@mEtk}P*o{i$C(cHQ7xu3PlgU$1)T&9n)r7sXc3o^jQX+22?7efaISp8NKT zn7z;MpYQnFqU%4HFzVOEbz{GI_uzTTp|PL768`SIFUQ?<+g|CuvG+Wh`{~%=ZO1UbGAH%Ks@@kYo6`4_wIAL)eel(>AMbwl{`TG*zx>6bOZ$xX>|OUyl=mr*m_xDY~{*>dzH86<^A)^ ztG2dZv2M`|4}Nun`r)n(p*xmWjC^r`rr$Vc#L9@iZ|7?de)(hmm`~4HP+vIYrs*F} z-2aQ4x2J9IRjExF72Hzwujy<4v0~1uS?lkaxw>sgPSI-@to-iU`O>c8FTOnE+8K{e z81?!$d3n8mc;@v#9DlRl9sih@x9&F^DsTVoxx(UzjylUNMM{&l4(*;X2KM3n?jV-3 zr=A_2bk5n~e?h6U(V3ETcKATxE3BsOe+*cNv(Z@#w6no`_rU+JdZ>3$5BN9sP_N#D z93Jg~pG$k7-;r{5{zvw}=dC^PLu34Ga=5SuIxqHs|5^|HT+svn@AbgX`#sQkvj=!p z4}8AV1AIjf@UcDcbGQdM$Vdu)r(dof+WSclbiVGPU4Q5Se?$-T3wyvn&;$LwJ&e1d zJXC1VZ1!uL%lSYD)^m#wE%E7KJVY7B1oU=puHQ&zRIs7KQD(F-RI%xvFo%L5Asp%mOSR>$Dn7;Ml4gz4NTYX&M z7d*@n$zP$XM%1ea$IA4hE0K4;)JIarFf{2Nev{@4{+oOp@G10(u5=V6{B+@zoX5eE z1NjW@;sCJ0u63ebX);eo1fAJ%rU`$YaD-M0{KJCIl505NTmk>RXm33^MYzy%cG(4; z4$)qdpO}!tI&!#hnR0tc;I9=GnsUezeD2KR_)(7yMi`nx}UOLMu%^mvQ)RLFZ~gM-lS;InS2*3;f4!{zndTz?|w?hACpQiuCqTWow=L3TNWI<<-z`sPma|FCuz|H=ZO+NED;++Ej zBGKMl;dqPgl>8=K$btMJy3+AGU+OC z=4_sxDDXFk{+)lCzO54NEfDQB>vce{`bmQ%X{W*nnR@c5XjheJmx=$n(8EJQ|JU;B zC7;00JPrQ<^2xr<68xC-mzZ++1t(zk%MJlQbedfnE$VGv!tu+{PP&c?{B)tWKjC0$ zxoB_hY3==;pwqORBbsa5k467>6ms}vLI2l+{_GVT{+*y-D(L%#og5(G=LtINM7^?r zQ{0E-AkE@{deL8FMSnH9IQ%(*|9eqy(`j0beJ^ z-DLv5m#NQ!e^U2cfOyCmiO81F=%oX;(m}g5af!`$Tn;15dSG3Cv@Bocni%}8D zGxtHB&KK}iru;>}j27^gzp|pJ#$R0RFDjCXO3NzBq$2l}iA5#8 zYTw+l8o#f4%EY|#$_n3<;yL9$o_F?~B5z$W5hyM%yAO!B)D}$^6!OZ8YifKolCQR? ztfIE^9$!(FucD-^Vy;x}D=sgu^h$w>;`t~;jCk)U^3J=bsI<7OTq^Ze_{*g#Uv+h5 zwNyN(vf2+Eq6Ka_LU|=}$|@@TWu*&?s^=FiDE52jNi}}3Uk%*Ss_L=|e<@L<+G~9N zqMC&$UR~s!V*(fl#eUEMhQADa%=P){URhdFypVtul?xbhxzAT6RTNiL*03k!l=^%n zMZQ{JgR(ipl-!q2k2E%pb8AKo~{YhP*K9D_SFQShj{XWjcSu50U!-FTBZ5E`Dg|}P`=UNbINRVK@F78F(!}_Vj zS6Un>_p=VB8m;M~DnB1vY@DJYU>ihBe5@iMGp#7`K^~P%OT6>S%1gQ$Y$kbYNm`Ug zcCEaQJy3fD6y~lg#S4^`Un>E0X;v#TyA>okpd9IIMWCvyXcvGZ6xS@Qu=Kx~?3O7;L1l%P^ceb0hRL*d z7RY>`e_kaG7(x;1L6382N?>S?#AKNmWF)<&j~Ql+{$Rsf-gmEy+-*h_8-~32M)2Nru8C zIG<0koRCGP3?sp*MSR_1FMlfXF{@fsG^eIUbafGR8Zdmdgfdc^ z;Bk-3E4psPbt6V4p0g8ASzQR%Tad3Gaa{uC#>7(>ZkAZbCrjo(i9Mwx(ze8tiIFU& zGFUJ6_Z`AJUjlh_|8W^nDfiQjj>rLYGSW7k>%-zwreCfrPS zoCa?a@w~0?D6Bjh#rmEl@TbE9zuyGnzS{yHVuA0mz^}8w4GUbTGRr+=f&a{c-)Vsh z7Fq6~4u#!GKS^87OR>PQ6i8ed7C4qNi7V3rH`gwdIobjzS(sO@1#Zfe@>B~P3Xr%8 zEb!h5s3c9dz|EK?WzV+2u?kLH^DJ;EVB)H>z|TuSvG;6&n`>*zuD8HR=gn)m1>VmD z;@)I|pKpP$vA{2|z}H&f{VnikEO0XhK-udoa5H8`@K-GG3ke{uW(yqAn8dZ!0yo#h zl-Xf{n=uc9@3z1%CV;s1Sm1+AAnt|*ZpIEN`;Z0xQwx5l1%9aoE{SnRdaGFAb_@J6 z3q0KdzuW>JWPv*@aK!>2YJq21;8$4SnHKn!7WiljJi`LdwZMm2;Hm|Fl?7g4fnRNb zPq)B_Ti~-Ta1knDx$`XW5f=O^3;bFOyv_p8w7}~v@GJ{_xdnc`1>R(VkF>zoSm2{9 z@U<5B4Hoz_7PuLcpzL)PxEXUI_$wB84gti~Y=H|C&vMk@e!Hrtrv6!x)KIfO)d<4+ zslj%8n^}_IG?%3}Q2Ja-XR`F)C{3m^s<8B*DNQCan$FU{qcoYusKnC0qBNPr=%G^p4E+VA z(H8>6CNH{4TrY^dcrGHLoGI7x+mYzdtGHua% zmcEP9WYVHlEIpahWXhtmS^5@AlL?C!u=F@elj(})vh>d=O(rXv$7A6$p!95(-cIRZlrCWD zR!WmeiRQBO21;K|=}eaX8>PvFL=~3)Go{INMAKRNca$cR5tUf_SCl4G5j}K*^*^OE zDZPiKAEGpwhG+*%KS*hEVWQ0}eIKRCL`2uIbTy^PG(^|3^v@|xCL!9y^Pg6v(x&*( z2ie`FH@=3!wSg+kYIbEeKainnJJgg%*8v)DR)ekSs(!Eiu$(?gIV?}#dRXp95B<_& z@3s}HOZPVcP1W|5sJd+^2~E`+9LoXAYBro`p4OVx9NHPUSq;DDco5ld(7=qp?H`e~ zQ+`8sg`FMF`p&ckeeT)WTa8D;Q+jvA_SOF|LSEU@vd1pJye+LmO?oHxwyOV~Q7uug zAIYkLLHPw*qb_YH24=LW;nc%bs67-{WmhK*&uf2EnBhr|?0(xJB`+vdqu|9j@{PW6Nj-ME*J=KOW>g+CHNklw)l~w#_-!ImP)p$!Kb!^R-Oe zC#%|zF8$a4APv(uHsj_D=OsI{H!qobi(Y;urkDKDG`FOqSt(#O-T}SLS7H~+({`eT zQ#0>N_MfY2->TYYMhFJfqwP^sf{adlvpd)h#V#Pl9!L5t#a4R4w`JyMH9I$ukn^+K z7SD0(ciNrdsuYrVQh5A{UpkK+4;Q4U-YwZ5_^(pE->5BnZEDg<)Rr&RTtqz~r%!|~ z^*IM4MAe;kEmQj-wwW@V@n(0hC0$MGq}o(%x?Q_I_RHy9q-_OI*&lwV0RDp-9`GbI z@eQ;W?H-MR)Cp-B7yJ;9>&b5IJGa&mZ%%5?Zdr0%J1)P_vGn*J8D~Au4>$bm(sW50 zDjkZ)gNE|UV{xY@$uC4a+B>TEP_zvaP_;2ny`V^KxR*SI`zzGawpVB}XnTdGz_tS8 zU+Cw%f_sj&p@R!Ciz}9)?Q#stY7TCC1(=c?`Xf3^Pn`jR=qT-b?Zr+2Ld}7TRqg9d z#J%xkXFLu-??`GEun2T)Gyb4kjHi&L1v3F-prpWLV+TM^t=({=rOxd3K&~Ml=a6Z1 z2V?|B>A3kI{J}8{P;~tz0AvwhGXNWCQqDT6Y7ygckkB?8MVR*V)K{NZB*;7k_^@q) zH5)2Btjbrp9Co_(aU7QKOs&L95=O2imTEXq6htw<0@^lOaDDpksta> z4n2>D+@qUqa>G-2+C(7&qZv{PHEXQeg_jyFN12sM@g5)*bZ)F@(EOd?PUMYQCa~GD!HU%A#fwXD&hlIBv>b&x+)qq zj8*h&stBmF6R6CSBp|Oh5-d+-QFYWRv*PO9`n^g1a#VaJ#tteTdLt^11gD#|MS`Qv z$3zQnf@gsi{$5m^Ya&E~s`ssOwzV$4KyDBF?@6B@A= zk0|v$9I{BTGl4;!M{NN{Iv!OWLl=`LpQAB(PW>L;7Hn6T=`Ap>!)O?z^h$;*2KSr@ zHV?n6ZEB%*^7gFw8yV;&V;THcSov3bgH~2E4663+k!Q)S?t*EedjJk!h%y3cSx1d& zK+lTbrD~lsX0#O`wd?CzB-~JqX1IPXmw+-V7dnK?{eZJzoV=Vkv$W$&i4K3=w&msPb-AY$VyGB6VtWlx-^Y6h$NX_fb4CNFyvm0dt(d-JkY zqU^n_>_}FYUczBbpTx`l%g36YNo5yN*|)!AJZFfqqgYuwqMW@V*DQNJFZ&8F>!7kr zsq8O!+0j%s*ggntHr+vIQ8b1j%iIN6nZ!x}b1S(E%qqztHU(%uz9HeYo2+=m=76x{ zMj!Mv<{+2Dw(vsZW^!Fd4-E9pI+_(XzC%MPBe=+6lNJtDwY_lij2U19Gx>S280)~B zk&H1C`&z%rVcdHTM*fR5E$TLhjzXcM8k;;9+O>@Yj-6*bfEp;vuz`%uphh;8V~C;V zg}rn(v8v%0iET6zlR5Mx5~Ks7O93+O!djO)ym}Dsu&Z{fT|Ida0)}+R?!iIUP8O=( zPt}$$ZK@vHgVG+|F=%4wEB_@P?Q3eyC$O6vFiF;nbQqR1_Aax^5T|x>a@NN=zcEno zftyurH@7d0P<@?U@?VkF%-lq9<3Ppn=0Jbr$8Sl7X@TC_r&K{Lz-qiL_9{G0xb2NZ zD_js~l!8Wj@OWJN!2c6ff0Ve3Z-2;>gkfZ)H*E8N75y2?Vv(m`a^o5WeVzlK??GT; zy1C)M6iGV;PfOKOjCW}+36Hr9Fk}8eng{&TfKyF#MtIb%ze3sY7#ngUsbi6#E0UTi zo>VQ>iN{Fl1pLJ`i>FKQ1SLa=(?t}zwKjr(zjQB{?t{rK)(T2udL}o2OnyiX$ZjMgvSv3@V}%c1Y#&6rJlu zikueYE#s*Io~lF2t^E^L-T4L{C1?C?TJymK+nm8uasLcee_%RF6|hpTlbv-&Tx3az zm^0GgsHaC}l9A_QJ36iTpS0qTz2VEdd1n4rBa^z-# z{7M3u=2N5LddxZ zWSSx90y0se%b)}KG+N+&C-7(nqYHRMgs!etPT+iZB%i^|c_Vf{22|EjGZ|GtvaNK4 zd}#wilP`6FRCr9wDh0Pxx=mGwb<#W#>^!e_0G7;;uRs>;P1>yZo>GQCtBs<_T|`iR zDJwtfK3*PHYp>dJ3IT&dYKw8RnzTjTamqgk#L5J*KAae5;&giTW3oX<3S6lM$J~qp zU`gBS@1yEtdIN6!VL#?H6?Svhmeh0rl8&6o&ks#tI(V}bI5&DXFgf3-|MOq)#zcu^ zyki!NFP~n%kVY@rIQi0gJV?Q4lIq=|>6Fl2E6O1ZCrLonJ?~})jU-4|0~nzq3SuQ~ zRdqX}9uX%rj>x-;-z4~ipJgmC;&Chk zf{5l9veh7_b?R@d2cJNe_Spt3FL|tQMpkolIbdd|Vp2OoQ3Wig?#{%Y3rppUFL9rg zfrnPCoTfMs&nX)E+C6L?<-zh?p4kHUOvj+Z^4;xtayX2a!4C>Kuxd|dD0du5YS-i=u|M`S+;VTLWLK;aim0+ti;&+PI#O{Ne+i=Bg4% zRYM;Kk}(%zVtVxe`lu;;yWH?Fx`IuL+V^lmoZ3GM^%v^E7PKb&d-;(a)bn~H%?%U1 z-`^6ptOm^i+g{Q@{ zztL9E<6@a&rMj&{)q1IGwBbw5feqdhgW9Eijzv@O^W@+cNx>fwxj5Dl++$1YDAmT> zVsDo=>CZB%QLH^k9RG zL5ysIdc)ZPanK}q^ygF{+;{IhVqjGLU343B&fW0t#uMt)uZarAlg>P_P_z8VQ-IUD z*b{!?8Bmy7i1i~}m#nX7>nt`%=&3W&pJUfdY%?V(Ek^<{msV7x1$!xppwe z0IK%Q7FR}ZNljTn`SQ!-(zKS~wxtct%Wp{wyri>PEvzQx=v1MmKZn0du0Y|ncu>9D zTw2NU6R|KK_ZZx~|F{K0`w7dVeZvKNZ;S*>6etLRTkH*1j`Z(wR8FgY?GOv%GI+|$f z>s7jWKStZ&MyIG@+ePZR>CU6=Nr5y~i>k+Vs6)1^Nk>#Iog{N^iZl3Ca^NEM*!${` z&8l`acgA_x+F5i2BPAskLw~x$HBgvMRLS`8@bAGI2Ezf5_HBHC`%y)jhyk(6<&ZJC z$S*H)$bk!U8{+=+5wSOJCtH}%XSdc!G~D{8T-;dsG?YiVK>vCal>B|E&|nl|@&P^} z0-qYj@IQRyO#J=PE_^}+eu0Vqr?cR{mcaLJA_<}z!gq5qy15vg*{9@3)naRKn$l>;u zYw&w)F-8MZ^-i*3YsenjhJB>K?KGQ(M>gt<{o&h^v`K#LR$I=b*-LI`meBQnCPtOo z^0`e7yX=QlZIDZwZI6VgVK)3|0_9_jjC%thfYEjn3h3Bwa;25nJ7ee;7c?bYzL_#N zr4v$k%BtzuLCQ70*@xJLmY=KNYKyI){v*5Z)=t6hyS0B6ZlHbXP0W}D_ou7jnGRbw z;bDEQYM&Z6qN_s9ORhKG*h7oQfpWt&=xP#8*Wy+V{fuDPHZjdQ^K7)u8>lTo?P9-3WyKxpvkL$%*XAcj3ocwNS>V>4DFsw@axj<8Ob~hs&WRZ6a@njR`;1T zQ?>dfNmMPWyd-)VBqH<+{!)KYTyE$MIO@*c95A}-{=BPhRw>mECaCVu(6m?!6b68K}ysZ9&07X2H8qFdrs%c_(n?2CRCq zb2dJXsRde;o8oTSo1D-$kM_AcbKkUY}Nab2D|X3Ex2ben&VDczX!$H9z)gv znyZt8`!33rS8aC5FHf?k!NhjJjaIV9_sQ3`%Ar{xj)WgNI{~0ahimE8~vvw z`Ez3qvyU&n$yuliP5> zKdZhjP0E#DJ`lK8)dvxKePTnKdf@MSigR=I41mA=Hgmk9)_~r9l40WlT}1s#sBn>- z+G|MXQoe>DR2zOTEC9NPc2?8z7@ZF&OGlr;6DB26oUEhq0RxsRrjCZkC1HNW z24(95$HV<|TfRsZJCsAh4_yuGwc*)6|M{w=pR;YssG@Cc`Qg%I-)J2>I)`m_YK_#_ z>Kg1Bg$L(C4Y70nX?(!?Mumn1cX#_>Zlh|W2f+e4zRlcNH=vW58*a~8Pp;A;8~N|p ztEE63^q^4XilDtuTh_eC&yQU#+JDx5-)Ee}{#T;kNphg+k}T^>5T{+z^wZ61@E{z^ z)bk(~)r-dTUjomiL)E9-$-rF@kOD&BN5|oqK>yl8)_j^j^?7zR z`(z-Kc^5D`)6+>JSeEhrLw~agg<_ZW*p)JczYns&WJ%8G>GDT+o_(YGizNRg`X(Ns zlb4^1hNxk`Bc1K<8`q;L6lEGt?Zbu6aOw>X+UA8A3n+`8Mb^ff@t}sU8M920V&_7y zg0ZCFk8x}$d)vs94BK)s$8W~xkx=+c9Bn|paR{OTQs86Y6YY7h%g8P#+Vm`FyS)t# zikxVzQ2NbiGg&p9tzeI_-rNsSgE7c0=D*erLKIw4^^t@0@e1gD6&bG(DcE^CCgOdD ziVY2{rI@5n^KXVijC|A2slVnR9Uzg|S!WvxIyq{P?YQB?g#W|$?wE|1?oWrXESlcn zumh0Q?AG?0{YPY7klO~*aJaV~EoN*5HFvl?6<+BUPxgV@fsluOJvc?9>W%F*jI(3a z2i!|f!BLQwyr!awL^u&x52WLu57lkjt~O)kZmx-XBSlQR{3pHf1ZuaY$vx>x!=^Pp zLnRXaWxvLCmb9v^r&oTFE%Z@u?4H)vE8X(7^=!h{R@3y`*0iOOOmkAAe7qDZIm>ua z!_yW~=p-_a_fJZ)8vMqlW*-lHPr5B>>zli^C)h~)rCs!bFLX~c`=k8`6O?J`7?&d> zt65Lo6jq>ca>Jt_p{M>8DcJEM#8LVUb`X3$;A}|n;~IxP=QZYIjZX*5H98P$I7S z-D>xz0X-#p7ma+(XNPGRZp1JoOUqaq`Zc2DU@KYz6tlfETM79lj03vAjzWwI#VZ8Y zv$2838KFLl=|&MaJk5SaH)8l%>^I^|q)cEe{Wjtb(KTZYP>{~U3i~sN(FM@vU8t6h zP+=D^>O|d%@xqVIW$KgcH0g$KPi9M@DL6d0G_suOn=2V!-{{DAj2Eb7t{rMm?ZnLm zN7XzjVAp%O^wJDSIkXvgh(OU=OFM};6%^sv_~DBn3pq3u2^{L%fL6yNy^w&fdP?@R zZXo*_>`az#Yt_cvjhEmoy7a%0Uyu*aG91E#+uP29qOiLutM&k(>b+I%Rz=l*qUOv{ zR%_FY56izpSPOwfolXV~LNVoN+D9YWO^(Cs~`YK#l4*KJsAhi@9~ z8ukraDSlxydcOyC$s}Qr{6LRY99~82@L0`e*k7G720E0>^a#mjc=; zjeF=(hZC_A3&`vbC?4Ubczg*@uxfGmp5k}&2Gcea7);KLlXG`?I5R8y!Wv2(hgd_1cr5Y zN953(go2olIk7v7gj|j5JJ5IK>ed=qrb#!p zuDd^N=}+w>hK|~;OGm?XutW$x1{;`EM952jJr`*hfYBUGu`icHF@s;NlLazCGxX4O zYQtc%txyldS3ff9A#zoJy?|3u=?3V}sUuz|Y*k-Hd7dz+q8h3#Yg@~{UPdD;xQaX= z4g2yt<LT>(MRXc(RFk^%}wf@&EFn0|3erUO&2%@OTSe)(_T!k>%qhek%4|At^^AO9u6 zPMiNFSe`}Wpx8&y6|p~pq4>_|{V0NM%5^~n8D}?LP$$G@ zAzRj3wQUkQk^Dht0nME+mm}%c-NTA&H7YIbY&rO^=p2zwdaj99D4+AIhABS&7J->a0?S5CN3&nR-} z1(4BNgI^3TrGDIr0N1gd!7q}Zxd;Yda>}dPooVlpwRfj1+XGbAqt}b2zZ@GzBhOs- z55}$(1*8tLfYdR=hJd}f_Qa0NW;@#9zs9LQ!kf*S5}iRq{-HNTcgPLDLnYKDE_6x2 zjo!4zN*j;~^BRD|h{z#UpRs4q!EmM$(Um9BU&xGiL?gWCjxJSjd?bemp?{yv?OFgu z&xN63{D=E4#f*dbrw_7$m8W9t6vV6GJB|R5#$GCcU&frV7Wz0K zcg9+Rtts%ww1LLuMH;0JX&v$HW^`kRiA9veiptxMRxCKIi3uDvkwPe^?0`sCt!osPHbq` zLy#;a0b9rzzYTGKRn#8t!A&B=nFE)LGNVHw8SPZ884iQuVI6kISk__3;Wum;Mh-*f z_IMoU#r}O)$))$oCufO1V(QV^D?4s4to{+V_NE&#+=)qVx^rsma_Ag%0PmsjxOlKN z$(h~3yGVX?43+hExY1BIq%kpRyEE9C;>N265QJMxachMn@$?H8Uxrs9PC)JmshRJc zP=+lDGH;cGgFwiw*Vtnfq?hPCEcdaop03jCCM~sCoK4451}(x=B>}<{2W1jy!8x>2 z@n|0*v0V;6ie5Y-SN5j)k3zp2@?Jf;fbc_qzLO25$XK%yUXt;ZD z%pqKm>CWCMH~Nv|&Tg%p00@*f-41B&xp>GWwze)Pf`Vud&MQk~~$FwIP#9~L`yE`;&z<+9d{2dkjG|hn9MrKKCjp>&4r*jJStq?M- z%|zuVwReqYfsZA2+HTa#@uSnx7L$HrxO7`@o_%G3;eyT@pTWkA7wU=*NSy&;+}BHP zpfs~^5ITP+&aG{y5y31THlk@1yOR#n=$NSA!p6ky3d#8V#Y3Fox)UvNjEr44^MNN(CbBoB$CI4D`o2kf!LxKT_ubj)=rxN}HH;qsx9kq%@M^%oM7oa;HR(HZd`#BfHI| zMPlEAFY>=PY>}nQL?8lAIHtg*`=3ciC+fAc`LP{~Q;y{UvT*Y0cbnOsAA9*lUjBD< zN&V}u(8MQ)R+9$kh0|5M2S9TvCVi629$5bS?08{uzz9f4)d~wj&2>Ks?vYt2S=F1G zQ5;}J)z;9XUYLP*DJNnOVp)99NWvi0^AI8N!zLUwzJLQtkyBzP;Zw>XnP@C+C;m+@ zfG@K6d`~6Upk(Y%!tc`az$O?3n~42@&A!NU9v>p5<=d7v=7PWy z5v2{bK9cgrwZL}D`5z$PsqHepB!V>AT@PV;viHahSK&c_ola40p-so*uoA{4?Uqi^ z{t9;_Uw?pzCj0+Dr2S7u*8pg-=lcD#SqRkl8+d>$Z%{1~KzBg`18&S09hDl!lL`sw ztec}Aq9x)kE=RgLrse`Pcx8(^rdKXKw5DxW$G9dk7(EsqOgz3^EgoMzI=vx;(_Sb> zD3hj)FBFfrj4#Y$kFSoMcll#oC^c^1WP!5sqU0nz+P4S#sAI+zj-M`vZla+a$t!^P zaIAefgcSV)X$pV*6&{UgEi?w}83r?nur3F;q4BBcbqf2d5XU3AE=T!g3vAU1w#bT^Um%I=GnCij01^y;gc6NU=nXJ`n>UWF3 zNy-0<{-&L3|Nor7dE5W7ziIrix68rg{^j%kt$$gQm_PsD^Dm8(1XIyc=pDJ5pF#N! zur33jp?n=yui&GmA_%Jb0c z+6nFZ2!jDE#aGjg9Br^>LM6yt9q)^D{c8@|io^8VA7v<;&b;FtNjdZ+Q;f~rz6w- z@Rzd2LI^a`DSWfawvmhsHmb0(hj1Xpb?!x9kz3XU#Y!AE;~AuYbp)1~`9VeSH#0tvAG#YH(L5=KrVy{e z1_y05(>|WZF^C%7jDq#NusF#sx^p*xCITMWGf9X&gH38P*ktF|;dP8o@5$T`G}}m^pQ1K4QZS1|Hn{!@Lv06Z+2` zp6SSdyq%fyvTexr=w+jc-H8N*rqKdzaw;R5K2_l`=q66)7qt=t`HH;k81miTzq5MK zVdRZCGdIyfT!nd5TfWB1;qBOh#J)eRyP8Qku-fAB2?`0E7N4MX&ROCU*wmqQ7j05` z^xhs?pnD@M^q}=Y-%P)T9Q(T4BH$14awIjxgG9R1Tc8{UN* z?=LIZHDSIviXir)k8EXUK8)?}A&P*&HXY&I#X6QYVA!a{3wv*)LlPqsJ#2G;Y%aR} zC1haz<!d)KO)_j|AEFJGe&3EH?{^jb{?7l{?~EV3)`S)h^dQ#i)a-7r$1&WQ z<8frj;SM(Xu!EBi!$Z9iz8&2TO+mMBMP$T($=SN6u>`$NeuNu6s|3H{Jx}^YuY8Q` z*dReWjd!r)>4a(w$1?SUXe#-uT5I%HEIAVXECH^Aewy(cG_-`y7-Ab`AN8*-wOYp<~MZEZcl`FLJ- zFQgRpF;Tf-!w@I?kj}l_3U#vd=fm{TExg={PHDl*ULWx{Q{H`5Ah|K1m1sZU3i;tL5v5^N!?z?clC%@}0HccTWmK_o6Kw&SQ_Si# zsgvrGV?{3vGEZwIjYsa&m`)m>@cjdwm=l_j4PEICA0b6<$UaKcI20Q?evdQwoP#-p zsy>r#lnrJdf5Lg zR~h9;?uLZPl7-9LFnF)uKr=WvR)cMJBTl=y*`EaVMMne69iHM?^a`ww6uT%PKNO_{ zT)|G*wqzjby|L#W>V&}chsa5U9sQ@eCbSI|w$sp)ANeQp!cGK4%nFsR3Lim*p6nPZ zd>L5Alh{&=KH5pT)A#a`tbs$WU=7Tt2Hrvq{PC|qtOX*OIy$1od@$H4ObHL6h0v%0 z>rs|Zm(vIQ9?!^al^e?`m(Si&l|&zW%|VChaAY_MS=5gdT!AyT{0neCG5nlkInof0 zQHm2KLUS(ulsfG-hH5+yW;W3a{zk)#6itzrk4H%-_PmLb*2eZ=*{gyG9yc46>+sbc z99rbB3Np}4fXtdnao|?{9YvRdFH}gB)*)%U|1mMJ&p5CfyRKl2=E{lq#uy#hOgQjv zeHPwl$wyHDalU(C?13h>y|>R8fLFIBhH!M?h`%gRonE8xZ`Yt7!TiE^DHH^c4_1u% znCUn?3eg>7F}u|JXhBV(APT_+@Wy*h261!`#WD!we-cSlV7Q6L(9ytZxbyaj*$3s2 z7xbxC^6!9nuDMo84&30}f^`aHCPnFhTWJ%K?1Xa{d(!w0qQR#U+DviE+Fzg~(UbV& z4s&Obu(tyncZ#(y`6ut2{ZtRVq<$Vq5YFvykl^7*3ULg?mU65CO+A2FqZ|jl?`9nG zBOJ!=7pPaklrahY8)_y7+EKdBqeZ%U6#e<+^PK#J+rZarF#FU<8t>7eC&*Ws*+P|T zAVT-vf9Fbz&FuhiF>F7$9Cc)2u*PtX{|QG1I(6}oZi6$oYpl%qhZvloMQbLqFVQOw zV>GB>gU)Nvau92x?*JM_AR$^zcRY`{n}RyXQZ>-N1XZe@St;f=)WIym0nABkfLbeE zi=r5zzs;nfIcmvebQ=>KjuHAkjnF$$Hy>x%11onZ8_7vA+OXNzZOHO-8d%$r3y-4^ zNE^Huom4z2H!edlWL@$(>S4zMKQT`#K18jq20=abA6|tGY8wuC`fD*{_;PQ+U&!Vk z~3$&(LwvI7xdS`k$t?*z@3*#ZWW0N8bdKkWwAux{%VHLzt9ax*AfNgr%u*JvcPw zL90uw>1NVdQ=9^wiC1`O;YKR~d07y20EY{Ql@Bd&fotqVji`$iLyZ8>+!4JKm|TKZ z!QVotR$ECGF_EK6h@S-C$%~QT56X>)x!_09R~lKk=d_@Nc1UDmM(r(Ln_BjmvMXS2L;=sS9hr@u696(pG*I>a} zhyqo#CxTcvPJJ~m+!Xr@<_EavwY$||-66?;K5S%?6z#;msOhh&dR-?Y7aa#$rA>57 zf=(#XDM#alZ=mAAcKH4D(ZLzBqHh@7Ywn8wvi((hXJqOAwP0BvXo+=U?*<_HV5S^$ zp$R%2e>?*F7wo)QZe)l4*LcE1U!AI8;yH=eDsr(7dk=4vU{Ou@I7KcuUq)apN;&l6l{(gdqTn)aDhUg<0x&F&Y zXMaVAeD00^8MX<{5eKrH{|KtE@g!Btju^Ql*b!R`sJSE7^?m^3S}Sk2b1uO-GQ3)*GXnn{kO*BU^2Q5MVdU}m#7T99J|DX3}G7! zkZqOo@(Q4K&7{~$$7DJgG`pN54jT&??XEoy0+3hH+jM)0zA^(*MnWDu&=m<0h%THy znTg+mwqwaVVAdBM#x2hg|-RU3>ik9POP3mkO%?#$*K_ zC=|+tb$1GUa$7pqq&8A9`oKb4U>3YKXd2!eJ7~NO0YQoQag6W;IwQig($>IuripcFw|9`33@6z`f3Y6HREWRGeg&%858vD4D z@J_T)7~|N}Oho}PW}@eW0_}kCtV&Z1ET-;!%1-_RbcnW8+4#c;ZyrN_^i~?DtC1z* zSom(pFDEGyzS4x#&&LCkbR4EU0)I3Qhp)sY+%C(xc0+ zji@h-`gENC?gaG&B)@DFphK&;x~gl6!!BVP?O=p!a5TVBiT_@x#4wU67&kt zCk{1yf38YLoQYel+>y%!;lW{D)dhC3X~~1-dZ-?z1pLe-&Sn#5^N6#mP_qXpG`>_i z!;5y+4WZUxWVUZ0OU54YhNt;B7TnU1q!w6)j&+e7 zin0XjC^}a!rWu!a2fX&4RLD<-b)f}y8pMA)p z?Sx-u^anX-@MJn{X7@6xc9@UrYS`7I{-vJmQ#7ut74~vh6F-l95^m*&OVJean`l|b zkKw>I=r-19v|#3(4#C3NyvD74g*W4gpu0uWBFSjRbtC43@7CUQ0}O zW`DcnGg3P$pHMsY(jnDlHn7dObgi()UG_#FNZ#5FKuZ_~^q&zxU<^)p-gNvKKwqcl zi?0zKwPUfSXkl}`{Hta;zqO&+e>JA^m8?L&!s!wIi8ArQGC2FUs&Jih;c2(VoOGUW z1P(=~`heaY6GuK&s0EZHFZaGdrK-HR87GTU-@A-J&b}ESnlWt@kTK8*CU5gmYUIMjnDt&(e{trc^Ksyq8 z7!PzsLIk1<{?A%G@+L+?W+*8VY66sSa5@(^BeadP_nR%4V`ET_gunlvcq-5Z|8R>Q z*o{xXC=U<~q}GoGdGQIupg21W=paBTX@WPBL-`1kxGt^;Qqy9>Nw9XZti|O>BOIu5+U`WB=Bz(835XV<9&ps?q zY-KOXQ6b~u&EUmbXb+D|CTB@q^{g%k5(0#%G@e6}+5$-pgrpi7h7i+|HdB4cX{slFdz24t0WkT{L(lRV43dx! zA?4_~_{-!&q4^%=!!pC{gSA{fdtrJ64akSG{}1Iu+;I7@x-9ZxIo;&LFob-HTF;P= zsxMY}yx{y#C|=N`yr!T|CNFyESzh~FSX&7xM=!u%CNC8aJ<5w^hS>*=xx8L_GC>3K zqU+B@`o?m)=^Mik`gU;Bnfmsh*i+axzl%>N;abF+ z=!HYO;by(Uy2JPl{ERMf8$U%)&^%U~sMxfVraht;2g1+qhQ#qdgZztG>Tiv?C^k`l z%0b&=6tda%2D|e&Igev6$qbk|XGZVGoNifvvGMZrv)JDf$c&8_dgyt)yoRb^8we>! zpN+puhQj_%$3tSg@KD|FfrvPu`JF{oe~}@DS5P57ZXS3dK?_Po*|81(Q6z)pJv%Xf zk*qI4t$L8SGb_ZT`9QEr24akwQyX?>ZYWxs4eEhJwEaQjebQ?bmL&)xh*UlI}kQBaXXIWKXxt!Gu znUOJ}5B4<9LuKek#3_)KSS{d?KM>FZc$JyfK@o;Wg(8h)qY}l*OrdxS2O}SxW9e_? zt$P44*6Qv zo6*~_m@wmD-E!JCQA3QUVV}EPY1V!mROi$23Irg~PjDs?D7qtE-gHdQi5Eip_@Kq= z$GYf-Q~x@^`aPI%>eJoQ7{&NnRdCE*s)D8UAfug(gqG?-lE$OyCmDYyCr(Qpc^Vwz zxWh^>D;|9i6fEN>_0^w&RL*FBpJ*CpUD4hyJ2hdR_4|lNx7Z>Rc>kP3!i-F?(=9L; z6=kwvGGP!N_d-P?6S(jvaN$p2!q*nmsoDe;Va10gC{n4$zRnPtu!xAL+HHvIOsE3F z>_}rhfpA3{8}PRtKhk^9zDQIPTa7f$2io_A^7=*=2GV}?=yPWuZMXSrb(y|S@C3@? zKh%&LHsXQwgBHy1;4KPTFw^c>K31xCw$jr?XeRqiZ|WbBe_yWvzS_z@84SH(IKTg!R19T1^4bpMg(bpUyA6w#UkbcGjgG zT}IuQ9-whzWSX?9^!w`)wB~6qn(T6NBy~%CmJv$_F^Bd6%7K-tvy@Gr!8yTrML4mK z(S8bY#Y1d+cmA})(6FUnkbT8aK1uH@&Yc~|);M|+MMT#_mIv+LhUqW|F`OVyXmHpXD<7rM*8&_GJO)r}w?-*LV(_1b=H2Y7fh z9jLMoiOHMz|AhuVw6;=k?thv-6fV0yiv33DnYI9*kFtCZPSqCACV=UGu}=PD2gPFW z$xZ50`DH6U)I=ZiLY^W;vEzgFNY>FP#*Ee8jCqW5zXFgXP4p0#qmk(!&Bi27AY7Zy z#^+9I&?Fk4Z?ch#)IbbTIwVQ2whTWkx3=I*lT#3|>f3Ofq5z#)J24GlLJItl_<}f} zmoSvuV!KMwAH?8!#KKY_itlB1%~zWSLH}sVdY4aGc8~U!ap5Ddtu#|H8xuN!gS{?I z!F+|>s&xN7j5~Z-Y5_K`@XYvTcBO?{FqP~Io#;)y4f$aFYDgX|e-0j9+Sl4gG<~&q znhcxaK)gkVegfYuv3I)k8|Eu@G|0p@zCsO+y~V9gLjUDW2+g**HOz23w8N~iL&l-8 z6dxsdv+p2T#tXxUJAv^9Fvtp^KhUdf5CdHq>_2!PrqnE~@%!d0zUu1AYWxTGBfR)i zR8?7CjwchxN9m#k#rO~E@n6B`-%&K)6 zWyz^1Ety|j$KaV=;Ifi(AO0(Q6Kt~LEBAT*iCU@BM1r&6t@aiBeVqTxSgD^W3yS^T zdA@38UU7|5R#97AURI)*|Ly%{!3b5+XKO4cxJkfI;Vc2xN)O3EtcCfZX`=~pT%6cc=J zz!&hb_6VVijGAG}jQ^yKvt}%SEJR(`C|R>cEKtUbQ5G;}to-m!g-A<$b;|s*n)xJW zB$au-;wr|-v|$+;lu%}r%^Egh!LWoT5WzA*Fws7SS?pK5#ptdCK_b*e1KB8w9-DF& z(*Ex9Vx_#55SqUXa;hz>EQfBCfM6LTG7{3y8m25-WL7}ER5pzIL}ao2Ye@yJHetii z5HN8Qn6Pq%niK6ft6WTZET~atU>wZqE(<_dhqL|`%I+<$pdQ93sPuwwWoUVcGH0RR zS2J8Go>N)vhbrI%4eB)q84U;O?6Q)&StCkIsEws1mi*EZ@4VuQxju8aB?_7uG(Iiu zsPN4#reO;z)T<^|4Qq_FnokfE?Q*>*WJjyB)DqCJwgZ{0o@E4a=)F{OYQ31IH z$`B~nb-ZLkj%5`>lBnMt!|2CiSPX>-B}Cd?mRW*<1RbC!v~!Nnzrg3KNYE>;C}9K{ zE!Z{idKEJUC?s?=Atry>d|&k$!edY_IqD6IysLcGWtAmm-ZP4r8A9HP{^Mhgp$lOq z>K5aXN|2zt)kC)Otc56}t3-lUX=U|2XYfS8)A;ei1Xl#A&OjA#j%{ggam~VtGaJjG zCT=&rtEzof#nor3qkx-b5`4odc+X^-^%Hdr*8x2COB6)L^n$oPoKo$bH**S7H7XWs!o^ zbw0~oiE*>Kdh_WWUn%YDb+rIpt=IBG%Kw3)db4@!<9MJmG@w%jw^I2 z_xONOelx16QY=J;#e;D+t04#}10-UVFB_!)ohmQ{uu=v0L4k|FW>PdlKuAMIoNiaj zDj)&KR^f%kbi?`#^9}1PlP!ipwwYTrnhe<#glX)|d6nENVLJXhmRa>+)yi%HW??uX zhXlVSbv99>N6*T#iPR(43A*5yIvLXQ2C8dlsx1jrlj>E&T`R8fDJ4EX+%`7zCOV2r z6qQs~_=b@dXV#5AbKW3jEn1+kNs#%EP>Fz_=`aH>s4nySeN51qG(l&85p$lnYFI{X zCHy?xuSnF%31S4A4k;UpiFPFH0_dEn4@zle0F%Xnd1d83xQ~@yUrh})l6Ng10H(J5 zKkc1=a9me)$JcLVS&=laV#aMnBFYQMMzkA^Y=mtlN+Kz%AGX(ynwW&N3$o;uY$dX- zNNZaLC8(89VY0FfRf9v+Mr}+Qr~)Z1i_)94j4f<&=~_YGcXWxOn?H#>d z<%M)$uXCqUr5#uk@V5=`r4YY8Z91knDk@0#w0Agd$)qgX5>9fzlRUKFNpy8~cJxZ1 zl%AF~!>wMKtbgz;ty?WG)!<^)9-?kBzJ*dOKJScOQ284)pY}K9Y#y z*)q}5*+xV$s|{5i`mmtRQRBC@C)q2e^xLWUXb!FGz)XpRXzWu%&%1AH@6K3oOK&oV z%dP?4X`WV{(dSf{&Y~Q{;`NfcS1k(Mdlu0I_>E6O*)PYC87VWLNl)iOS7X!&1@09S z_g(uz&^#;*4x{5xb+|r3?`Cy)hgjp2p7Rd0Tsn=D+$?l^?o#*Q2M$);z!YOFO*#d6hpnTv>O|_BS{E#j4e{x83%y zyN7SNv-aG zvjJ}h$H6t=N$|J88E^x*06Kr*x@AS7(0jpRo+~~ER)f1AM<2f$IhbKPw%-2re0oCFua1u*pl zSEpQJt<8Bc)`a0ZNmHJ@?a1h@#E08<=NFUtMXlyehuJcAz={8Q=+c7vC| zIWUj*);vRdz&Ws*b}xc4a0yI+#XOA~0L#EJFal13HQ+QD1Lwdvcn$0Zhq2cHI1Z-3 zli(yc15SYp;0(9~&Vj43YuTSuE*Jq5U^h4nPJ-j$z~^W`cAn$y?rw0Bb3pm4#u0u4 z72{kd@|WlbC%;6yI0lRGf=@X(04Bgma15LSrzM|bpgFLNgXIXveKlYdEaN%a066|t z$_2Z5bAAzwa4c6w|Hi>;Fa^fJ?teiaICq(Q`aRCCyavEUa2%As13m?ge~bF8rv2Y$ z9E0&W`T?x@F74+*!xR_=$G=BDSTm0tI0s$>&lz>A-kl}F5U7gMTZIoLwDVL`)|Id{2d}F z@=-ol@q0@MI*DwY&lTto3$4yB8M3S{8{d>9aszxyKa3rOpp($Y_&7&g*AdzdyJRau zQlCja+-pKqt1FZ!?X*^QoeN&W|IyuhnZG3`DG zy;BJ2w-R=N)U6!)H1vNLdc9q8#HzPTN5hS_lgg{JD@ImE?W&=C>l=1Oo$ZhXOT8&D zf=B}SPU8E0BHv(_q^vr-bR^thJ41O^)Gno{4E{0rd$8L-3cqe=mGw-aYG<@)n|D!1 zvxC{Zip3+ZmDi4XtdltE>f8I|}w{Cw5puZkBQ$5;>iOzM76) z#RHkOLZf_vGCmRLrP%d1grMrRqtGt!>LGG5@_$M_Y9(K%7$~n1NPj#`?8eT=!4JPU-QV)qmUVTC1rL`zSrW8#H)&5{P!A=Q#8J z1JpxVY3L+{V> zxBAmK+!?xUM!9G;EO{980{lM_e(I(D6K5XE6LUUT$T%`?y47os^luGv$622Q`$Ni? z_02Kps{H%xk`b%HE*%OpJ|9KPY25gX2@lGDhoyY@e@EL_mrwsl`L*G9V~BJGJb#N) z&J=QQ9A}>8I?yi|E9h5E_9@F6Sl%&dzs+O4HQMjGfS;s&We`4+gI*22D+fIW{Q>C8 zLd1tgS}FETK;HuWKXt!n+P60Rop7Lex&~7IIC4w)3DdudH}|1W=qI619Cuxog?HRUR}bH7nSMmS=k%juFGG5jeGK|3 z=<6hqX8B_if%rtw9dvvVeKVqueL>J4B|a{QKIogc_U0|7#@%*FRF9`T2EaV|w@bcG z5;x1B7kq|y9kgHSd6l@J_A~1r)AMcGPAYC3F!2h#l4RU0ihlM-U(@Z;@i+Il*=hYv z&hV?tm+>n5rk~J0wXO-a&#|_c>Z<;S?`_mm`qm_=&j9r2{@8UN(fxd#`ZU>tE5cWE zPY5cI4WLiGMRZ{n zP1+_Cko?AHP|Dxx`|lRp3EwRJts_779tw|0n@KW0hmo83GvtJZ9fz#&3>7T68@i0c z6Vm0Map=wLUti1YUz~4QoZ4p3-)f!8IpDm7h?FylzANm5*+%(E z>^=?sD)jGO-|no}Gwm+>Z}}StA4%K&@5Ju)*eizKGWOkXJdgjg{}sDkXM9Fwd`1d$ zHb9Nf2r9bK*U!FM9U`UsL9H{a=RFT+BM_DDmiEfNzu=VXR&s5U_}xk94)k{jG3|Hs z{${(h$(tu+eIVyG74W^R?XUfT@u$}Z${(8S3oF7O&EXKr@G?HjIcNAJ`=2LudFU@`oj#eHrb-+r15q)9Rlgca_>$eY-UWzEDbMb^_lci>1lCn%?f_xI$7 zhB?O}{;&5bo0%Rbb1I7#b>^gd-JsU_#q9Jd{>gPeNikB+viK<*sQe~--m_X+6#p#7&kMfpx)Y)&UG6s9v3@sQuw;7s?i%>} z;Xf_}{7$de?twp+=HD6&J8E1ek()>Eu*j)#WgRm9B=KyF{Mv8)@_J{Gdk(o=dL^F7 zIbOkx>oV;9B<1CCeiwrN%d|u6UW42o2b3U7eABVtn56W zyWY|-a;|)e{C=(j{j%M5dedf>Jd*HVg1_XO+Hccwmi^aIo=C9yGv-$N6FIN0f`393 zEbGUp9T{c8+a$ ztSEZDcp~F1&R4}n*JT>=lk|5Ix&!^KLRI5mc6MG8xiOt@Xp$rJNxn*v3(`g3H1rba z?-NG$NpYfdb5V=ZDRK*ZRb|NueTgrrU-o`Q&ZDJ%9KZTW_#@DTKe)dTx|~}J|ESOH zjl($f+`_9?JWm->hg+9oGzVoUO4)+9&7r&B%R1pR&|MX3FzX)8_74g@etm!0~ zwb6vm;0RQuztRe1Z7HeLgOI;AxZo&?99>8%(ekp6kYv_GEFDz(vg4tlzwmbN-qf=| z*N-D+l}veWx?cT5n%~v;rd(b_Q0+UZA13^_zR%No{;$9l-9Op&$zSVHeofIa6@mY;8YCNOyvc^|6zOFI*OC)%d!`{0d#Z#18ei0SM&o6TuWEclb7i<*Mwzq2+b=aR2^-z?u z_P#z@q7?gcyFlGC_yle70F~P{2IA~DbiI8OC zT7h@#f6FkDIv9BqCk^h@n>8s{c#OP>UscdVw~-I&xNFeFSy)su^M$$J#D&B>BX8oI z!DcOB>TmcAHXtuC)ZCjmYVZYJPqVGk<^h9d z-Vk}&cW2A*fhJAN=Of9?lLpQF=jD23nQOsae1h^<*Lb-G)w^jPNqut^oPn}e56bV< zaloMA*J6JC&HbS)d3lFilEE)L;@z9?Y<=?VAy~dy7Z|+B2x=5t2h$KYB5(S?O0O#n zzB72(0AF_bk7vp6_&fxX!Qrd|vu;CA!W%4q_6tfpWN^tW5IpiS`#l3))=V-!B$;*4 zh4bFM886;ldiUaki>^zGV%t`kr|W^>2+J^f+uC-sL^5M48EKtZ|1+V z7d;76&un>fKg)&aGVPzg=%}n&Enh3aHISUZwOoFOk2X<8j*+j