From e1207e1d0dbc4a253998fb54c8b8a2a413a9f442 Mon Sep 17 00:00:00 2001 From: Alexis Jhon Gaspar Date: Thu, 12 Oct 2023 23:08:23 +0800 Subject: [PATCH] Added slim-fork to the repo - This introduces a minimalist display manager for the suckless-utils suite - Added crudely written scripts for reloaading slim's theme via pywal, meaning no on-the-fly reloading using keybinds as nost people wouldn't have their sudo passwordless - This is based on slim-fork 1.4.0 version. --- README.md | 7 + config/wal/templates/slim-reload | 5 + config/wal/templates/slim.theme | 52 + slim/CMakeLists.txt | 252 ++++ slim/COPYING | 339 +++++ slim/ChangeLog | 196 +++ slim/Ck.cpp | 152 +++ slim/Ck.h | 49 + slim/INSTALL | 39 + slim/PAM.cpp | 309 +++++ slim/PAM.h | 106 ++ slim/README | 69 + slim/THEMES | 136 ++ slim/TODO | 17 + slim/app.cpp | 1455 +++++++++++++++++++++ slim/app.h | 115 ++ slim/cfg.cpp | 478 +++++++ slim/cfg.h | 58 + slim/cmake/modules/FONTCONFIGConfig.cmake | 71 + slim/cmake/modules/FindCkConnector.cmake | 59 + slim/cmake/modules/FindDBus.cmake | 72 + slim/cmake/modules/FindPAM.cmake | 74 ++ slim/const.h | 40 + slim/image.cpp | 958 ++++++++++++++ slim/image.h | 75 ++ slim/jpeg.c | 101 ++ slim/log.cpp | 57 + slim/log.h | 47 + slim/main.cpp | 24 + slim/numlock.cpp | 112 ++ slim/numlock.h | 33 + slim/pam.sample | 10 + slim/panel.cpp | 1035 +++++++++++++++ slim/panel.h | 188 +++ slim/png.c | 173 +++ slim/slim.1 | 126 ++ slim/slim.conf | 124 ++ slim/slim.service | 10 + slim/slimlock.1 | 78 ++ slim/slimlock.conf | 11 + slim/slimlock.cpp | 342 +++++ slim/slimlock.pam | 2 + slim/switchuser.cpp | 74 ++ slim/switchuser.h | 45 + slim/themes/CMakeLists.txt | 1 + slim/themes/default/CMakeLists.txt | 5 + slim/themes/default/COPYRIGHT.background | 1 + slim/themes/default/COPYRIGHT.panel | 1 + slim/themes/default/LICENSE.panel | 340 +++++ slim/themes/default/background.jpg | Bin 0 -> 278157 bytes slim/themes/default/panel.png | Bin 0 -> 15641 bytes slim/themes/default/slim.theme | 52 + slim/themes/original/CMakeLists.txt | 5 + slim/themes/original/COPYRIGHT.background | 2 + slim/themes/original/COPYRIGHT.panel | 16 + slim/themes/original/LICENSE.panel | 340 +++++ slim/themes/original/background.jpg | Bin 0 -> 154967 bytes slim/themes/original/panel.png | Bin 0 -> 16123 bytes slim/themes/original/slim.theme | 37 + slim/themes/suckless/panel.png | Bin 0 -> 15641 bytes slim/themes/suckless/slim.theme | 52 + slim/util.cpp | 70 + slim/util.h | 25 + slim/xinitrc.sample | 23 + 64 files changed, 8745 insertions(+) create mode 100755 config/wal/templates/slim-reload create mode 100644 config/wal/templates/slim.theme create mode 100644 slim/CMakeLists.txt create mode 100644 slim/COPYING create mode 100644 slim/ChangeLog create mode 100644 slim/Ck.cpp create mode 100644 slim/Ck.h create mode 100644 slim/INSTALL create mode 100644 slim/PAM.cpp create mode 100644 slim/PAM.h create mode 100644 slim/README create mode 100644 slim/THEMES create mode 100644 slim/TODO create mode 100644 slim/app.cpp create mode 100644 slim/app.h create mode 100644 slim/cfg.cpp create mode 100644 slim/cfg.h create mode 100644 slim/cmake/modules/FONTCONFIGConfig.cmake create mode 100644 slim/cmake/modules/FindCkConnector.cmake create mode 100644 slim/cmake/modules/FindDBus.cmake create mode 100644 slim/cmake/modules/FindPAM.cmake create mode 100644 slim/const.h create mode 100644 slim/image.cpp create mode 100644 slim/image.h create mode 100644 slim/jpeg.c create mode 100644 slim/log.cpp create mode 100644 slim/log.h create mode 100644 slim/main.cpp create mode 100644 slim/numlock.cpp create mode 100644 slim/numlock.h create mode 100755 slim/pam.sample create mode 100644 slim/panel.cpp create mode 100644 slim/panel.h create mode 100644 slim/png.c create mode 100644 slim/slim.1 create mode 100644 slim/slim.conf create mode 100644 slim/slim.service create mode 100644 slim/slimlock.1 create mode 100644 slim/slimlock.conf create mode 100644 slim/slimlock.cpp create mode 100644 slim/slimlock.pam create mode 100644 slim/switchuser.cpp create mode 100644 slim/switchuser.h create mode 100644 slim/themes/CMakeLists.txt create mode 100644 slim/themes/default/CMakeLists.txt create mode 100644 slim/themes/default/COPYRIGHT.background create mode 100644 slim/themes/default/COPYRIGHT.panel create mode 100644 slim/themes/default/LICENSE.panel create mode 100644 slim/themes/default/background.jpg create mode 100644 slim/themes/default/panel.png create mode 100644 slim/themes/default/slim.theme create mode 100644 slim/themes/original/CMakeLists.txt create mode 100644 slim/themes/original/COPYRIGHT.background create mode 100644 slim/themes/original/COPYRIGHT.panel create mode 100644 slim/themes/original/LICENSE.panel create mode 100644 slim/themes/original/background.jpg create mode 100644 slim/themes/original/panel.png create mode 100644 slim/themes/original/slim.theme create mode 100644 slim/themes/suckless/panel.png create mode 100644 slim/themes/suckless/slim.theme create mode 100644 slim/util.cpp create mode 100644 slim/util.h create mode 100644 slim/xinitrc.sample diff --git a/README.md b/README.md index 109ae2f..0544bab 100644 --- a/README.md +++ b/README.md @@ -17,6 +17,7 @@ This was designed to save me some sanity in maintaining it as well as easily int - dwmblocks-async - slock - nsxiv +- slim ### Terminal - dvtm @@ -25,6 +26,12 @@ This was designed to save me some sanity in maintaining it as well as easily int ## Notes +### slim notes + +To reload the preset theme (located in `/usr/share/themes/slim/suckless`), then run `.cache/wal/slim-reload` **after** running pywal. The script must also be ran as sudo. + +This is, if you wanted a display manager added. The scripts also works a workaround unless if slim could handle loading themes from other dirs. + ### eww notes The weather widget is pretty barebones as of now. Report bugs if found. diff --git a/config/wal/templates/slim-reload b/config/wal/templates/slim-reload new file mode 100755 index 0000000..53c9a2c --- /dev/null +++ b/config/wal/templates/slim-reload @@ -0,0 +1,5 @@ +#!/bin/sh +# Reloads slim (needs sudo to ask the passswoes) + +sudo cp .cache/wal/slim.theme /usr/share/slim/themes/suckless +sudo cp {wallpaper} /usr/share/slim/themes/suckless/background.png diff --git a/config/wal/templates/slim.theme b/config/wal/templates/slim.theme new file mode 100644 index 0000000..f51d547 --- /dev/null +++ b/config/wal/templates/slim.theme @@ -0,0 +1,52 @@ +# Green glass theme for SLiM +# by Rob Pearce + +# Messages (e.g. shutdown) +msg_color {color15} +msg_font Hack Nerd Font:size=18:bold:dpi=75 +msg_x 50% +msg_y 40% +msg_shadow_color #702342 +msg_shadow_xoffset 1 +msg_shadow_yoffset 1 + +# valid values: stretch, tile +background_style stretch +background_color {color0} + +# Input controls +input_panel_x 50% +input_panel_y 45% +input_name_x 394 +input_name_y 142 +input_pass_x 394 +input_pass_y 178 +input_font Hack Nerd Font:size=12:dpi=75 +input_color {color0} + +# Username / password request +username_font Hack Nerd Font:size=18:dpi=75 +username_color {color15} +username_x 270 +username_y 144 +password_x 270 +password_y 180 +username_shadow_color {color0} +username_shadow_xoffset 1 +username_shadow_yoffset 1 + +username_msg Username: +password_msg Password: + +# Welcome message +welcome_font Hack Nerd Font:size=28:bold:dpi=75 +welcome_color {color1} +welcome_x 50% +welcome_y 40 +welcome_msg Login to %host +welcome_shadow_xoffset 2 +welcome_shadow_yoffset 2 +welcome_shadow_color {color0} + +passwd_feedback_x 50% +passwd_feedback_y 80% diff --git a/slim/CMakeLists.txt b/slim/CMakeLists.txt new file mode 100644 index 0000000..628c86e --- /dev/null +++ b/slim/CMakeLists.txt @@ -0,0 +1,252 @@ +cmake_minimum_required(VERSION 2.8.12 FATAL_ERROR) + +set(PROJECT_NAME slim) +project(${PROJECT_NAME}) + +#Pretty colors +set(CMAKE_COLOR_MAKEFILE ON) +#Dont force verbose +set(CMAKE_VERBOSE_MAKEFILE ON) +#Include current dir +set(CMAKE_INCLUDE_CURRENT_DIR TRUE) + +INCLUDE(CheckIncludeFile) +INCLUDE(CheckCCompilerFlag) +INCLUDE(CheckCXXCompilerFlag) +INCLUDE(CheckTypeSize) +INCLUDE(GNUInstallDirs) + +# Version +set(SLIM_VERSION_MAJOR "1") +set(SLIM_VERSION_MINOR "4") +set(SLIM_VERSION_PATCH "0") +set(SLIM_VERSION "${SLIM_VERSION_MAJOR}.${SLIM_VERSION_MINOR}.${SLIM_VERSION_PATCH}") + +set(PKGDATADIR "${CMAKE_INSTALL_FULL_DATADIR}/slim") +set(SYSCONFDIR "/etc") + +set(SLIM_DEFINITIONS) +if(${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD" OR + ${CMAKE_SYSTEM_NAME} MATCHES "NetBSD" OR + ${CMAKE_SYSTEM_NAME} MATCHES "OpenBSD" + ) + set(SLIM_DEFINITIONS ${SLIM_DEFINITIONS} "-DNEEDS_BASENAME") +else() + set(SLIM_DEFINITIONS ${SLIM_DEFINITIONS} "-DHAVE_SHADOW") +endif() + +set(SLIM_DEFINITIONS ${SLIM_DEFINITIONS} "-DAPPNAME=\"${PROJECT_NAME}\"") +set(SLIM_DEFINITIONS ${SLIM_DEFINITIONS} "-DVERSION=\"${SLIM_VERSION}\"") +set(SLIM_DEFINITIONS ${SLIM_DEFINITIONS} "-DPKGDATADIR=\"${PKGDATADIR}\"") +set(SLIM_DEFINITIONS ${SLIM_DEFINITIONS} "-DSYSCONFDIR=\"${SYSCONFDIR}\"") + +# source +set(slim_srcs + main.cpp + app.cpp + numlock.cpp + switchuser.cpp + png.c + jpeg.c +) + +set(slimlock_srcs + slimlock.cpp +) + +set(common_srcs + cfg.cpp + image.cpp + log.cpp + panel.cpp + util.cpp +) +if(USE_PAM) + set(common_srcs ${common_srcs} PAM.cpp) + # used to always build slimlock if we are using PAM. Removed as per Devuan + # set(BUILD_SLIMLOCK 1) +endif(USE_PAM) + +# Build common library +set(BUILD_SHARED_LIBS ON CACHE BOOL "Build shared libraries") + +if (BUILD_SHARED_LIBS) + message(STATUS "Enable shared library building") + add_library(libslim ${common_srcs}) +else(BUILD_SHARED_LIBS) + message(STATUS "Disable shared library building") + add_library(libslim STATIC ${common_srcs}) +endif(BUILD_SHARED_LIBS) + +if(USE_CONSOLEKIT) + set(slim_srcs ${slim_srcs} Ck.cpp) +endif(USE_CONSOLEKIT) + +add_executable(slim ${slim_srcs}) +if(BUILD_SLIMLOCK) + add_executable(slimlock ${slimlock_srcs}) +endif(BUILD_SLIMLOCK) + +#Set the custom CMake module directory where our include/lib finders are +set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/modules") + +find_package(X11 REQUIRED) +find_package(Freetype REQUIRED) +find_package(JPEG REQUIRED) +find_package(PNG REQUIRED) + +# Fontconfig +set(FONTCONFIG_DIR ${CMAKE_MODULE_PATH}) +find_package(FONTCONFIG REQUIRED) +if(FONTCONFIG_FOUND) + message("\tFontConfig Found") + target_link_libraries(slim ${FONTCONFIG_LIBRARY}) + include_directories(${FONTCONFIG_INCLUDE_DIR}) +endif(FONTCONFIG_FOUND) + +# PAM +if(USE_PAM) + message("\tPAM Enabled") + find_package(PAM) + if(PAM_FOUND) + message("\tPAM Found") + set(SLIM_DEFINITIONS ${SLIM_DEFINITIONS} "-DUSE_PAM") + target_link_libraries(slim ${PAM_LIBRARY}) + target_link_libraries(libslim ${PAM_LIBRARY}) + if(BUILD_SLIMLOCK) + target_link_libraries(slimlock ${PAM_LIBRARY}) + endif(BUILD_SLIMLOCK) + include_directories(${PAM_INCLUDE_DIR}) + else(PAM_FOUND) + message("\tPAM Not Found") + endif(PAM_FOUND) +else(USE_PAM) + message("\tPAM disabled") +endif(USE_PAM) + +# ConsoleKit +if(USE_CONSOLEKIT) + find_package(CkConnector) + message("\tConsoleKit Enabled") + if(CKCONNECTOR_FOUND) + message("\tConsoleKit Found") + # DBus check + find_package(DBus REQUIRED) + if(DBUS_FOUND) + message("\tDBus Found") + target_link_libraries(slim ${DBUS_LIBRARIES}) + include_directories(${DBUS_ARCH_INCLUDE_DIR}) + include_directories(${DBUS_INCLUDE_DIR}) + set(SLIM_DEFINITIONS ${SLIM_DEFINITIONS} "-DUSE_CONSOLEKIT") + target_link_libraries(slim ${CKCONNECTOR_LIBRARIES}) + include_directories(${CKCONNECTOR_INCLUDE_DIR}) + else(DBUS_FOUND) + message("\tDBus Not Found") + endif(DBUS_FOUND) + else(CKCONNECTOR_FOUND) + message("\tConsoleKit Not Found") + message("\tConsoleKit disabled") + endif(CKCONNECTOR_FOUND) +else(USE_CONSOLEKIT) + message("\tConsoleKit disabled") +endif(USE_CONSOLEKIT) + +# system librarys +find_library(M_LIB m) +find_library(RT_LIB rt) +find_library(CRYPTO_LIB crypt) +find_package(Threads) + +add_definitions(${SLIM_DEFINITIONS}) + +#Set up include dirs with all found packages +include_directories( + ${X11_INCLUDE_DIR} + ${X11_Xft_INCLUDE_PATH} + ${X11_Xrender_INCLUDE_PATH} + ${X11_Xrandr_INCLUDE_PATH} + ${FREETYPE_INCLUDE_DIRS} + ${X11_Xmu_INCLUDE_PATH} + ${ZLIB_INCLUDE_DIR} + ${JPEG_INCLUDE_DIR} + ${PNG_INCLUDE_DIR} +) + +target_link_libraries(libslim + ${RT_LIB} + ${X11_Xft_LIB} + ${X11_Xrandr_LIB} + ${JPEG_LIBRARIES} + ${PNG_LIBRARIES} +) + +#Set up library with all found packages for slim +target_link_libraries(slim + ${M_LIB} + ${RT_LIB} + ${CRYPTO_LIB} + ${X11_X11_LIB} + ${X11_Xft_LIB} + ${X11_Xrender_LIB} + ${X11_Xrandr_LIB} + ${X11_Xmu_LIB} + ${FREETYPE_LIBRARY} + ${JPEG_LIBRARIES} + ${PNG_LIBRARIES} + libslim +) + +if(BUILD_SLIMLOCK) + #Set up library with all found packages for slimlock + target_link_libraries(slimlock + ${M_LIB} + ${RT_LIB} + ${CRYPTO_LIB} + ${X11_X11_LIB} + ${X11_Xft_LIB} + ${X11_Xrender_LIB} + ${X11_Xrandr_LIB} + ${X11_Xmu_LIB} + ${X11_Xext_LIB} + ${FREETYPE_LIBRARY} + ${JPEG_LIBRARIES} + ${PNG_LIBRARIES} + ${CMAKE_THREAD_LIBS_INIT} + libslim + ) +endif(BUILD_SLIMLOCK) + +####### install +# slim +install(TARGETS slim RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}) + +if (BUILD_SHARED_LIBS) + set_target_properties(libslim PROPERTIES + OUTPUT_NAME slim + SOVERSION ${SLIM_VERSION}) + + install(TARGETS libslim + LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} + ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} + ) +endif (BUILD_SHARED_LIBS) + +# man file +install(FILES slim.1 DESTINATION ${CMAKE_INSTALL_MANDIR}/man1) + +# configure - in theory we should use CMAKE_INSTALL_SYSCONFDIR but that doesn't work +install(FILES slim.conf DESTINATION ${SYSCONFDIR}) + +# systemd service file - commented out as broken - not all Linux uses systemd! +#if (${CMAKE_SYSTEM_NAME} MATCHES "Linux") +# install(FILES slim.service DESTINATION ${LIBDIR}/systemd/system) +#endif (${CMAKE_SYSTEM_NAME} MATCHES "Linux") + +#slimlock +if(BUILD_SLIMLOCK) + install(TARGETS slimlock RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE SETUID) + install(FILES slimlock.1 DESTINATION ${CMAKE_INSTALL_MANDIR}/man1) +endif(BUILD_SLIMLOCK) + +# themes directory +subdirs(themes) diff --git a/slim/COPYING b/slim/COPYING new file mode 100644 index 0000000..a43ea21 --- /dev/null +++ b/slim/COPYING @@ -0,0 +1,339 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 675 Mass Ave, Cambridge, MA 02139, USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + Appendix: How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) 19yy + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) 19yy name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Library General +Public License instead of this License. diff --git a/slim/ChangeLog b/slim/ChangeLog new file mode 100644 index 0000000..095ba44 --- /dev/null +++ b/slim/ChangeLog @@ -0,0 +1,196 @@ +1.4.0 - 2023.01.21 + * - BREAKING CONFIG CHANGE - the position of the passwd_feedback in slim + is now relative to the screen, not the panel. This is now consistent + with slimlock and with the session and other messages. + * The selected session is now preserved over failed logins + * When testing themes with the -p option, the size of the window can now + be specified, and the theme is previewed correctly for that size. + * On exit from theme test, the "test message" now reports user and session + * Failed login feedback is now disabled by default or if position negative + * Applied some Devuan patches + - Set the XDG_SESSION_CLASS. This fixes Gentoo bug #727544 - failure to + register sessions with elogind in some instances. The (incorrect) bug + note in the man page has therefore been removed again. + - Use $DISPLAY instead of hardcoding :0.0 in sessionstart/stop commands + - No longer always builds slimlock if using PAM - it must be explicitly + enabled + - Fixed formatting in slimlock man page + - A couple of typos fixed in strings + * Updated the README and encoded in UTF-8 + * Corrected the handling of the -n / -nodaemon option so that it doesn't + swallow the next option if given as -n + * Bug fixes in slimlock + - The active entry is for password, so show the password prompt, not the + username one + - Don't react to F1, as it isn't appropriate and used to blank the + screen + - Keep it all on one screen even when the WM hasn't set a "primary" for + RandR purposes + * Fix ticket #4 - the config parser now works properly. Previously it got + confused by option names that were substrings of other option names + * Themes with "background_style color" no longer need a redundant image + file to make them work. + - This needed a bit of a re-write of the image handling, which also + improves efficiency + * New default theme - the old one is retained as "original" + * Some general documentation improvements (man pages, comments in example + files) + +1.3.9 - 2022.11.18 + * Changed the handling of the "auth failed" message in DM mode so that it + remains on display until a key is pressed. + * Added a command line option to specify the configuration file + * Allow the logfile to be specified as "stderr" to write to stderr + Also now writes all log messages to stderr if they are printed before + the log file is open, including when using the -p option. + * Added a configuration option to retain the user name if authentication + fails (which is probably more helpful if you just mistype your password) + * Applied a modified version of the "wait for the X server" patch from guix + * No longer unnecessarily re-opens an already open X display interface. + Similarly removed a redundant "get root window" call + * Deleted some unused member variables and methods. Various other internal + clean-up + * Reverted the install location definition for the configuration file, as + the CMAKE_INSTALL_SYSCONFDIR wasn't right + * Added a "bug" note to the man page, for the reliance on sessreg, which + causes occasional misbehaviour for some people. + +1.3.8 - 2022.03.01 + * Fixed some bugs listed on bugs.gentoo.org: + 832303 - failed to build with clang, Invalid suffix on string literal + 580458 - open fd on /var/log/slim.log passed to session + * Fixed handling of log stream so that all the code uses the same instance + * Handle return values from calls, to clean up warn-unused-result warnings + * Fixed "sessions" config option (the earlier patch was incomplete) + * Several QA improvements + * Updated cmake config - use standard install paths, don't force options + +1.3.7 - 2022.01.30 + * Imported several bug fixes from the Gentoo package: + libslim-cmake-fixes + disable-ck-for-systemd + reinstate sessions config option as an alternative to sessiondir + systemd session compatibility + remove zlib dependency + envcpy-bad-pointer-arithmetic patch + add-missing-libgen_h + wrong comparison for XCreateGC error return (GCC11 needs it fixed!) + * Fixed a bug in handling expired user accounts with PAM + * Show a message on login failure (using the same method as slimlock) + + + --- The releases below were the original SLiM project --- + +1.3.6 - 2013.10.01 + * Merge slimlock. + * Add support ^H (like backspace). + * And fix some bugs. + +1.3.5 - 2012.12.31 + * Support UTF8 string. + * Add systemd service. + * And fix some bugs. + +1.3.4 - 2012.06.26 + * Replaced stderr writes function. + * Fix numlock control. + * Fix build with GLUT. + * Fix PAM authentication. + +1.3.3 - 2012.02.22 + * Change build system to CMake. + * Add support ConsoleKit. + * Fix some bugs.... + +1.3.2 - 2010.07.08 + * Add support xauth secret. + * Add xnest_debug mode. + +1.3.1 - 2008.09.26 + * Added focus_password config option for focusing password + automatically when default_user is enabled + * Added auto_login option + * Fixed uninitialized daemonmode, see + http://www.freebsd.org/cgi/query-pr.cgi?pr=114366 + * Fixed maximum length for password + * Introduced customization options for session text: + font, colors, position, shadows. + +1.3.0 - 2006.07.14 + * Added PAM support by Martin Parm + * Fixed segfault on exit when testing themes. Thanks + to Darren Salt & Mike Massonnet + * Fixed vt argument detection, thanks to Henrik Brix Andersen + * Corrected reference to input_color in the default theme + * Fixed default shell setting + * Fix segfault when calling XCloseDisplay(NULL); thanks Uli Schlachter + +1.2.6 - 2006.09.15 + * Bug #008167: Update pid when in daemon mode + * Fixed warnings when compiling with -Wall. Thanks to + KIMURA Masaru + * Fixed major memory leaks with repeated login (bug #007535) + +1.2.5 - 2006.07.24 + * hiding of the cursor is now an option (disabled + by default) since some WMs does not re-initialize + the root window cursor. + * The X server is restarted when the user logs out. + This fixes potential security issues with user-launched + apps staying attached to the root window after logout. + * Bug #7432 : Added proper Xauth authentication: the X server + is started with the -auth option and the user who logs + in has his .Xauthority file initializated. + +1.2.4 - 2006.01.18 + * Added commands for session start and stop + (i.e. for session registering) + * Added automatic numlock on/off option + * Support for numpad Enter key + * Restored support for daemon option in the config + file. + * Lock file now uses process id, no more false + locking (thanks to Tobias Roth) + +1.2.3 - 2005.09.11 + * Added FreeBSD, NetBSD, OpenBSD support + * Replaced autotools with plain makefile(s) + * Added 'suspend' command (untested, we don't use it) + * Added support for %theme variable in login command + +1.2.2 - 2005.05.21 + * fix panel drawing on screens <= 1024x768 + * Don't start X server unless valid theme found + * revert to 'default' of invalid theme specified + * try all themes from a set if one doesn't work + +1.2.1 - 2005.05.17 + * draw input directly on panel + +1.2.0 - 2005.05.16 + * added theme preview (slim -p /path/to/theme) + * added JPEG support for panel image + * added 'center' background type and 'background_color' option + * added text shadow + * added warning when execution of login command fails + * Fix login failure when no shell specified in /etc/passwd + * Print error when login command execution fails + * add XNEST_DEBUG ifdef's to allow for easy debugging + * Add support for Ctrl-u and Ctrl-w + * Add 'vt07' to server arguments if not already specified + * Removes daemon option from the config file. Use slim -d + * Allow 'current_theme' to be a set of themes, choose randomly + * Change default theme + +1.1.0 - 2004.12.09 + * error messages for X11 apps are no longer redirected + to the log file + * fixed text position for default theme + * added configurable shutdown and reboot messages + * separated 'Enter username' and 'Enter password' messages + position. + * due to the previous two points, the theme format has + slightly changed + +1.0.0 - 2004.12.07 + * First public SLiM release diff --git a/slim/Ck.cpp b/slim/Ck.cpp new file mode 100644 index 0000000..dad4f05 --- /dev/null +++ b/slim/Ck.cpp @@ -0,0 +1,152 @@ +/* SLiM - Simple Login Manager + * Copyright (C) 2011 David Hauweele + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + */ + +#include +#include + +#include +#include +#include +#include + +#include "Ck.h" + +namespace Ck +{ + Exception::Exception(const std::string &func, const std::string &errstr) + : func(func), errstr(errstr) + { + } + + dbus_bool_t Session::ck_connector_open_graphic_session( + const std::string &display, + uid_t uid) + { + dbus_bool_t local = true; + const char *session_type = "x11"; + const char *x11_display = display.c_str(); + const char *x11_device = get_x11_device(display); + const char *remote_host = ""; + const char *display_dev = ""; + + return ck_connector_open_session_with_parameters(ckc, &error, + "unix-user", &uid, + "session-type", &session_type, + "x11-display", &x11_display, + "x11-display-device", &x11_device, + "display-device", &display_dev, + "remote-host-name", &remote_host, + "is-local", &local, + NULL); + } + + const char * Session::get_x11_device(const std::string &display) + { + static char device[32]; + + Display *xdisplay = XOpenDisplay(display.c_str()); + + if(!xdisplay) + throw Exception(__func__, "cannot open display"); + + Window root; + Atom xfree86_vt_atom; + Atom return_type_atom; + int return_format; + unsigned long return_count; + unsigned long bytes_left; + unsigned char *return_value; + long vt; + + xfree86_vt_atom = XInternAtom(xdisplay, "XFree86_VT", true); + + if(xfree86_vt_atom == None) + throw Exception(__func__, "cannot get XFree86_VT"); + + root = DefaultRootWindow(xdisplay); + + if(XGetWindowProperty(xdisplay, root, xfree86_vt_atom, + 0L, 1L, false, XA_INTEGER, + &return_type_atom, &return_format, + &return_count, &bytes_left, + &return_value) != Success) + throw Exception(__func__, "cannot get root window property"); + + if(return_type_atom != XA_INTEGER) + throw Exception(__func__, "bad atom type"); + + if(return_format != 32) + throw Exception(__func__, "invalid return format"); + + if(return_count != 1) + throw Exception(__func__, "invalid count"); + + if(bytes_left != 0) + throw Exception(__func__, "invalid bytes left"); + + vt = *((long *)return_value); + + std::sprintf(device, "/dev/tty%ld", vt); + + if(return_value) + XFree(return_value); + + return device; + } + + void Session::open_session(const std::string &display, uid_t uid) + { + ckc = ck_connector_new(); + + if(!ckc) + throw Exception(__func__, "error setting up connection to ConsoleKit"); + + if (!ck_connector_open_graphic_session(display, uid)) { + if(dbus_error_is_set(&error)) + throw Exception(__func__, error.message); + else + throw Exception(__func__, "cannot open ConsoleKit session: OOM," + " DBus system bus not available or insufficient" + " privileges"); + } + } + + const char * Session::get_xdg_session_cookie() + { + return ck_connector_get_cookie(ckc); + } + + void Session::close_session() + { + if(!ck_connector_close_session(ckc, &error)) { + if(dbus_error_is_set(&error)) + throw Exception(__func__, error.message); + else + throw Exception(__func__, "cannot close ConsoleKit session: OOM," + " DBus system bus not available or insufficient" + " privileges"); + } + } + + Session::Session() + { + dbus_error_init(&error); + } + + Session::~Session() + { + dbus_error_free(&error); + } +} + +std::ostream& operator<<( std::ostream& os, const Ck::Exception& e) +{ + os << e.func << ": " << e.errstr; + return os; +} diff --git a/slim/Ck.h b/slim/Ck.h new file mode 100644 index 0000000..a3f8486 --- /dev/null +++ b/slim/Ck.h @@ -0,0 +1,49 @@ +/* SLiM - Simple Login Manager + * Copyright (C) 2007 Martin Parm + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + *(at your option) any later version. + */ + +#ifndef _CK_H_ +#define _CK_H_ + +#include + +#include +#include + +namespace Ck +{ + class Exception + { + public: + std::string func; + std::string errstr; + Exception(const std::string &func, const std::string &errstr); + }; + + class Session + { + private: + CkConnector *ckc; + DBusError error; + + const char *get_x11_device(const std::string &display); + dbus_bool_t ck_connector_open_graphic_session(const std::string &display, + uid_t uid); + public: + const char *get_xdg_session_cookie(); + void open_session(const std::string &display, uid_t uid); + void close_session(); + + Session(); + ~Session(); + }; +} + +std::ostream &operator<<(std::ostream &os, const Ck::Exception &e); + +#endif /* _CK_H_ */ diff --git a/slim/INSTALL b/slim/INSTALL new file mode 100644 index 0000000..3e41238 --- /dev/null +++ b/slim/INSTALL @@ -0,0 +1,39 @@ +INSTALL file for SLiM + +0. Prerequisites: + - cmake + - X.org or XFree86 + - libxmu + - libpng + - libjpeg + +1. to build and install the program: + o Using the ccmake interactive tool: + - cd into a clean directory, e.g. "mkdir slim; cd slim" + - unpack the code, e.g. "tar zxf ../slim-1.4.0.tar.gz" + - create a build directory and change to it, e.g. "mkdir build; cd build" + - run ccmake to configure for your OS, e.g. "ccmake ../slim-1.4.0" + . press 'c' to configure and 'e' to ignore warnings + . set the CMAKE_INSTALL_PREFIX and other variables as needed + . continue pressing 'c' until the 'g' option is available + . press 'g' to generate the files needed + - run "make" + - run "make install" + + o Using command line only: + - cd into a clean directory + - unpack the code + - create a build directory and change to it + - run cmake to configure for your OS and options + - build and install as above + e.g. + mkdir slim; cd slim + tar zxf ../slim-1.4.0.tar.gz + mkdir build; cd build + cmake ../slim-1.4.0 -DCMAKE_INSTALL_PREFIX=/opt -DUSE_PAM=yes -DUSE_CONSOLEKIT=yes + make + make install + +2. automatic startup + Edit the init scripts according to your OS/Distribution. An example for + systemd is provided diff --git a/slim/PAM.cpp b/slim/PAM.cpp new file mode 100644 index 0000000..088ce05 --- /dev/null +++ b/slim/PAM.cpp @@ -0,0 +1,309 @@ +/* SLiM - Simple Login Manager + * Copyright (C) 2007 Martin Parm + * Copyright (C) 2022 Rob Pearce + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + */ + +#include +#include +#include "PAM.h" + +namespace PAM +{ + Exception::Exception(pam_handle_t* _pam_handle, + const std::string& _func_name, + int _errnum) + : errnum(_errnum), errstr(pam_strerror(_pam_handle, _errnum)), + func_name(_func_name) + {} + + Exception::~Exception(void) {} + + Auth_Exception::Auth_Exception(pam_handle_t* _pam_handle, + const std::string& _func_name, + int _errnum) + : Exception(_pam_handle, _func_name, _errnum) + {} + + Cred_Exception::Cred_Exception(pam_handle_t* _pam_handle, + const std::string& _func_name, + int _errnum) + : Exception(_pam_handle, _func_name, _errnum) + {} + + int Authenticator::_end (void) + { + int result=pam_end(pam_handle, last_result); + pam_handle=0; + return result; + } + + Authenticator::Authenticator(conversation* conv, void* data) + : pam_handle(0), last_result(PAM_SUCCESS) + { + pam_conversation.conv=conv; + pam_conversation.appdata_ptr=data; + } + + Authenticator::~Authenticator(void) + { + if (pam_handle) + _end(); + } + + void Authenticator::start(const std::string& service) + { + switch ((last_result=pam_start(service.c_str(), NULL, &pam_conversation, &pam_handle))) { + default: + throw Exception(pam_handle, "pam_start()", last_result); + + case PAM_SUCCESS: + break; + } + return; + } + + void Authenticator::end(void) + { + switch ((last_result=_end())) { + default: + throw Exception(pam_handle, "pam_end()", last_result); + + case PAM_SUCCESS: + break; + } + return; + } + + void Authenticator::set_item(const Authenticator::ItemType item, const void* value) + { + switch ((last_result=pam_set_item(pam_handle, item, value))) { + default: + _end(); + throw Exception(pam_handle, "pam_set_item()", last_result); + + case PAM_SUCCESS: + break; + } + return; + } + + const void* Authenticator::get_item(const Authenticator::ItemType item) + { + const void* data; + switch ((last_result=pam_get_item(pam_handle, item, &data))) { + default: + case PAM_SYSTEM_ERR: +#ifdef __LIBPAM_VERSION + case PAM_BAD_ITEM: +#endif + _end(); + throw Exception(pam_handle, "pam_get_item()", last_result); + + case PAM_PERM_DENIED: /* The value of item was NULL */ + case PAM_SUCCESS: + break; + } + return data; + } + +#ifdef __LIBPAM_VERSION + void Authenticator::fail_delay(const unsigned int micro_sec) + { + switch ((last_result=pam_fail_delay(pam_handle, micro_sec))) { + default: + _end(); + throw Exception(pam_handle, "fail_delay()", last_result); + + case PAM_SUCCESS: + break; + } + return; + } +#endif + + void Authenticator::authenticate(void) + { + switch ((last_result=pam_authenticate(pam_handle, 0))) { + default: + case PAM_ABORT: + case PAM_AUTHINFO_UNAVAIL: +// _end(); +// throw Exception(pam_handle, "pam_authenticate()", last_result); + + case PAM_USER_UNKNOWN: + case PAM_MAXTRIES: + case PAM_CRED_INSUFFICIENT: + case PAM_ACCT_EXPIRED: + case PAM_PERM_DENIED: + case PAM_AUTH_ERR: + throw Auth_Exception(pam_handle, "pam_authentication()", last_result); + + case PAM_SUCCESS: + break; + } + + switch ((last_result=pam_acct_mgmt(pam_handle, PAM_SILENT))) { + /* The documentation and implementation of Linux PAM differs: + PAM_NEW_AUTHTOKEN_REQD is described in the documentation but + don't exists in the actual implementation. This issue needs + to be fixes at some point. */ + + default: + /* case PAM_NEW_AUTHTOKEN_REQD: */ + case PAM_ACCT_EXPIRED: + case PAM_USER_UNKNOWN: + case PAM_AUTH_ERR: + case PAM_PERM_DENIED: + throw Auth_Exception(pam_handle, "pam_acct_mgmt()", last_result); + + case PAM_SUCCESS: + break; + } + return; + } + + void Authenticator::check_acct(void) + { + switch((last_result=pam_acct_mgmt(pam_handle, PAM_SILENT))){ + case PAM_ACCT_EXPIRED: + case PAM_USER_UNKNOWN: + case PAM_PERM_DENIED: + throw Auth_Exception(pam_handle, "pam_acct_mgmt()", last_result); + + default: + //case PAM_NEW_AUTHTOKEN_REQD: + case PAM_AUTH_ERR: + case PAM_SUCCESS: + break; + }; + } + + void Authenticator::open_session(void) + { + switch ((last_result=pam_setcred(pam_handle, PAM_ESTABLISH_CRED))) { + default: + case PAM_CRED_ERR: + case PAM_CRED_UNAVAIL: + _end(); + throw Exception(pam_handle, "pam_setcred()", last_result); + + case PAM_ACCT_EXPIRED: + case PAM_PERM_DENIED: + case PAM_CRED_EXPIRED: + case PAM_USER_UNKNOWN: + throw Cred_Exception(pam_handle, "pam_setcred()", last_result); + + case PAM_SUCCESS: + break; + } + + switch ((last_result=pam_open_session(pam_handle, 0))) { + /* The documentation and implementation of Linux PAM differs: + PAM_SESSION_ERROR is described in the documentation but + don't exists in the actual implementation. This issue needs + to be fixes at some point. */ + + default: + /* case PAM_SESSION_ERROR: */ + pam_setcred(pam_handle, PAM_DELETE_CRED); + _end(); + throw Exception(pam_handle, "pam_open_session()", last_result); + + case PAM_SUCCESS: + break; + } + return; + } + + void Authenticator::close_session(void) + { + switch ((last_result=pam_close_session(pam_handle, 0))) { + /* The documentation and implementation of Linux PAM differs: + PAM_SESSION_ERROR is described in the documentation but + don't exists in the actual implementation. This issue needs + to be fixes at some point. */ + + default: + /* case PAM_SESSION_ERROR: */ + pam_setcred(pam_handle, PAM_DELETE_CRED); + _end(); + throw Exception(pam_handle, "pam_close_session", last_result); + + case PAM_SUCCESS: + break; + } + switch ((last_result=pam_setcred(pam_handle, PAM_DELETE_CRED))) { + default: + case PAM_CRED_ERR: + case PAM_CRED_UNAVAIL: + case PAM_CRED_EXPIRED: + case PAM_USER_UNKNOWN: + _end(); + throw Exception(pam_handle, "pam_setcred()", last_result); + + case PAM_SUCCESS: + break; + } + return; + } + + void Authenticator::setenv(const std::string& key, const std::string& value) + { + std::string name_value = key+"="+value; + switch ((last_result = pam_putenv(pam_handle, name_value.c_str()))) { + default: + case PAM_PERM_DENIED: + case PAM_ABORT: + case PAM_BUF_ERR: +#ifdef __LIBPAM_VERSION + case PAM_BAD_ITEM: +#endif + _end(); + throw Exception(pam_handle, "pam_putenv()", last_result); + + case PAM_SUCCESS: + break; + } + return; + } + + void Authenticator::delenv(const std::string& key) + { + switch ((last_result = pam_putenv(pam_handle, key.c_str()))) { + default: + case PAM_PERM_DENIED: + case PAM_ABORT: + case PAM_BUF_ERR: +#ifdef __LIBPAM_VERSION + case PAM_BAD_ITEM: +#endif + _end(); + throw Exception(pam_handle, "pam_putenv()", last_result); + + case PAM_SUCCESS: + break; + } + return; + } + + const char* Authenticator::getenv(const std::string& key) + { + return pam_getenv(pam_handle, key.c_str()); + } + + char** Authenticator::getenvlist(void) + { + return pam_getenvlist(pam_handle); + } +} + +std::ostream& operator<<( std::ostream& os, const PAM::Exception& e) +{ + os << e.func_name << ": " << e.errstr; + return os; +} diff --git a/slim/PAM.h b/slim/PAM.h new file mode 100644 index 0000000..925ea62 --- /dev/null +++ b/slim/PAM.h @@ -0,0 +1,106 @@ +/* SLiM - Simple Login Manager + Copyright (C) 2007 Martin Parm + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +*/ + +#ifndef _PAM_H_ +#define _PAM_H_ +#include +#include + +#ifdef __LIBPAM_VERSION +#include +#endif + +namespace PAM +{ + class Exception + { + public: + int errnum; + std::string errstr; + std::string func_name; + Exception(pam_handle_t* _pam_handle, + const std::string& _func_name, + int _errnum); + virtual ~Exception(void); + }; + + class Auth_Exception: public Exception + { + public: + Auth_Exception(pam_handle_t* _pam_handle, + const std::string& _func_name, + int _errnum); + }; + + class Cred_Exception: public Exception + { + public: + Cred_Exception(pam_handle_t* _pam_handle, + const std::string& _func_name, + int _errnum); + }; + + + class Authenticator + { + private: + struct pam_conv pam_conversation; + pam_handle_t* pam_handle; + int last_result; + + int _end(void); + + public: + typedef int (conversation)(int num_msg, + const struct pam_message **msg, + struct pam_response **resp, + void *appdata_ptr); + + enum ItemType { + Service = PAM_SERVICE, + User = PAM_USER, + User_Prompt = PAM_USER_PROMPT, + TTY = PAM_TTY, + Requestor = PAM_RUSER, + Host = PAM_RHOST, + Conv = PAM_CONV, +#ifdef __LIBPAM_VERSION + /* Fail_Delay = PAM_FAIL_DELAY */ +#endif + }; + + public: + Authenticator(conversation* conv, void* data=0); + ~Authenticator(void); + + void start(const std::string& service); + void end(void); + void set_item(const ItemType item, const void* value); + const void* get_item(const ItemType item); +#ifdef __LIBPAM_VERSION + void fail_delay(const unsigned int micro_sec); +#endif + void authenticate(void); + void check_acct(void); + void open_session(void); + void close_session(void); + void setenv(const std::string& key, const std::string& value); + void delenv(const std::string& key); + const char* getenv(const std::string& key); + char** getenvlist(void); + + private: + /* Explicitly disable copy constructor and copy assignment */ + Authenticator(const PAM::Authenticator&); + Authenticator& operator=(const PAM::Authenticator&); + }; +} + +std::ostream& operator<<( std::ostream& os, const PAM::Exception& e); +#endif /* _PAM_H_ */ diff --git a/slim/README b/slim/README new file mode 100644 index 0000000..c6c1598 --- /dev/null +++ b/slim/README @@ -0,0 +1,69 @@ +README file for SLiM + +Rob Pearce + +INTRODUCTION + SLiM (Simple Login Manager) is a graphical login manager for X11. + It aims to be simple, fast and independent from the various + desktop environments. + SLiM was originally based on the last stable release of Login.app + by Per Lidén. + + Features: + - External themes and configuration + - PNG support with alpha transparency for panel + - PNG / JPEG support for backgrounds + - XFT / freetype support + - Double or single (GDM-style) inputbox support + - PAM support for authentication + - Compatible with ConsoleKit or logind, OpenRC or systemd, etc. + - CMake build procedure + +INSTALLATION + see the INSTALL file + +USAGE + SLiM is intended to be run automatically as part of the system + startup. Get your SysVInint, OpenRC or systemd to run the slim + executable, with the -d option if you want it to run as a daemon + in the background (recommended for OpenRC, systemd may work + better without) + + As you would expect of a login manager, you enter your username + and password to login. By default, the ~/.xinitrc file is run, + so be sure to have a working .xinitrc file in your home. This + behaviour is configurable, and may be set up differently by the + distro package. + + Special usernames can be entered to run commands that are + configurable in the config file: + - console: start a console login + - exit: exit SLiM (this may not have desirable results) + - halt: shut down the system + - reboot: reboot the system + + Pressing the F11 key executes a user-specified command (see the + configuration file). The default is to take a screenshot, if the + 'import' program is available. + +CONFIGURATION + /etc/slim.conf is the main configuration file. Alternative files + can be specified on the command line. + Options are explained in the file itself + +THEMES + The appearance (and some parts of the behaviour) of SLiM depends + on the "theme" specified by the configuration file. See the file + THEMES for details. + +COPYRIGHT + SLiM is copyright (c) 2004-13 by Simone Rota, Johannes Winkelmann, + Nobuhiro Iwamatsu and 2022-23 by Rob Pearce. It is available under the + GNU General Public License. + See the COPYING file for the complete license. + + Image handling code adapted and extended from xplanet 1.0.1, + copyright (c) 2002-04 by Hari Nair + + Login.app is copyright (c) 1997, 1998 by Per Liden and is + licensed through the GNU General Public License. diff --git a/slim/THEMES b/slim/THEMES new file mode 100644 index 0000000..935e708 --- /dev/null +++ b/slim/THEMES @@ -0,0 +1,136 @@ +Quick THEME howto for SLiM + +Some basic information regarding the slim theme format. +Read this file if you plan to make some theme for +the program, and of course have a look at the included themes + +GENERAL CONCEPT + A SLiM theme essentially consists of: + - a background image (background.png or background.jpg) + - a panel image (panel.png or panel.jpg) + - input box(es) and messages and their placement + and properties (slim.theme) + + The panel and background images can be a PNG or JPEG file. + The panel is blended into the background image, + taking care of alpha transparency. + +SUPPORTED FORMATS + - fonts: use the xft font specs, ie: Verdana:size=16:bold + - colors: use html hex format, ie #0066CC + - positions: can be either absolute in pixels, ie 350 + or relative to the container, ie 50% is in the middle + of the screen. + +OPTIONS + The following is an example slim.theme file + ---------------------------------------------------------------------- + # Color, font, position for the messages (ie: shutting down) + msg_color #FFFFFF + msg_font Verdana:size=16:bold + msg_x 50% + msg_y 30 + + # Color, font, position for the session list + session_color #FFFFFF + session_font Verdana:size=16:bold + session_x 50% + session_y 90% + + # style of background ('stretch', 'tile', 'center') and color + background_style stretch + background_color #FF0033 + + # Horizonatal and vertical position for the panel. + input_panel_x 50% + input_panel_y 40% + + # Input controls horizontal and vertical positions relative to + # the panel. + # Set input_pass_x and input_pass_y to -1 to use a single input + # box for username/password (GDM Style). + # Note that these fields only accept absolute values. + input_name_x 40 + input_name_y 100 + input_pass_x 40 + input_pass_y 120 + + # Input controls font and color + input_font Verdana:size=12 + input_color #000000 + + # Welcome message position. (relative to the panel) + # use -1 for both values or comment the options to disable + # the welcome message + welcome_x 50% + welcome_y 38 + + # Font and color for the welcome message + welcome_font Verdana:size=16:bold:slant=italic + welcome_color #d7dde8 + + # 'Enter username' font and foreground/background color + username_font Verdana:size=12 + username_color #d7dde8 + + # 'Enter username' and 'Enter password' position (relative to the panel) + # use -1 for both values to disable the message + # note that in case of single inputbox the password values are ignored. + username_x 50% + username_y 146 + password_x 50% + password_y 146 + + # The message to be displayed. Leave blank if no message + # is needed (ie, when already present in the panel image) + username_msg Please enter your username + password_msg Please enter your password + + # Optional message to show on a failed login. Similar set of values + # to the above. Use -1 for the x & y to disable (default). + password_feedback_x 50% + password_feedback_y 165 + password_feedback_msg Authentication failed + # The font and color are inherited from msg_xxx + ---------------------------------------------------------------------- + +SHADOWS + + The 'msg', 'input', 'welcome', 'session' and 'username' sections + support shadows; three values can be configured: + - color: the shadow color + - x offset: the offset in x direction, relative to the normal text + - y offset: the offset in y direction, relative to the normal text + + So to add a text shadow to the welcome message, add the following + to slim.conf: + ---------------------------------------------------------------------- + welcome_shadow_xoffset -2 + welcome_shadow_yoffset 2 + welcome_shadow_color #ff0000 + ---------------------------------------------------------------------- + + The other keys are analogous: + ---------------------------------------------------------------------- + # for username and password label + username_shadow_xoffset 2 + username_shadow_yoffset -2 + username_shadow_color #ff0000 + + # for the input fields + input_shadow_xoffset 1 + input_shadow_yoffset 1 + input_shadow_color #0000ff + + # for the messages: + msg_shadow_xoffset 1 + msg_shadow_yoffset 1 + msg_shadow_color #ff00ff + + # For the session: + session_shadow_xoffset 1 + session_shadow_yoffset 1 + session_shadow_color #ff00ff + ---------------------------------------------------------------------- + + diff --git a/slim/TODO b/slim/TODO new file mode 100644 index 0000000..f0130c6 --- /dev/null +++ b/slim/TODO @@ -0,0 +1,17 @@ +Important things +---------------- +- Make it work better with multi-screen setups + +Improvements suggested long ago +------------------------------- +- Don't start X server if theme's not found +- i18n +- FreeBSD fixes +- restart X server on ctrl-alt-backspace + +Other thoughts for improvement +------------------------------ +- position text to fit screen, e.g. when at 90% position +- allow nested config +- make slimlock handle themes the same as slim +- option to run X server as non-root diff --git a/slim/app.cpp b/slim/app.cpp new file mode 100644 index 0000000..237477d --- /dev/null +++ b/slim/app.cpp @@ -0,0 +1,1455 @@ +/* SLiM - Simple Login Manager + * Copyright (C) 1997, 1998 Per Liden + * Copyright (C) 2004-06 Simone Rota + * Copyright (C) 2004-06 Johannes Winkelmann + * Copyright (C) 2022 Rob Pearce + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + */ + +#include +#include +#include +#include // for getpwnam etc. +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "const.h" +#include "log.h" +#include "numlock.h" +#include "switchuser.h" +#include "util.h" +#include "app.h" + +#ifdef HAVE_SHADOW +#include +#endif + +using namespace std; + +#ifdef USE_PAM +#include + +int conv(int num_msg, const struct pam_message **msg, + struct pam_response **resp, void *appdata_ptr) +{ + *resp = (struct pam_response *) calloc(num_msg, sizeof(struct pam_response)); + Panel* panel = *static_cast(appdata_ptr); + int result = PAM_SUCCESS; + int i; + + for (i = 0; i < num_msg; i++) + { + (*resp)[i].resp = 0; + (*resp)[i].resp_retcode = 0; + switch (msg[i]->msg_style) + { + case PAM_PROMPT_ECHO_ON: + /* We assume PAM is asking for the username */ + panel->EventHandler(Panel::Get_Name); + switch (panel->getAction()) + { + case Panel::Suspend: + case Panel::Halt: + case Panel::Reboot: + (*resp)[i].resp=strdup("root"); + break; + + case Panel::Console: + case Panel::Exit: + case Panel::Login: + (*resp)[i].resp=strdup(panel->GetName().c_str()); + break; + default: + break; + } + break; + + case PAM_PROMPT_ECHO_OFF: + /* We assume PAM is asking for the password */ + switch (panel->getAction()) + { + case Panel::Console: + case Panel::Exit: + /* We should leave now! */ + result = PAM_CONV_ERR; + break; + + default: + panel->EventHandler(Panel::Get_Passwd); + (*resp)[i].resp=strdup(panel->GetPasswd().c_str()); + break; + } + break; + + case PAM_ERROR_MSG: + case PAM_TEXT_INFO: + /* We simply write these to the log + TODO: Maybe we should show them. In particular, if you + have a fingerprint reader, PAM passes instructions + in PAM_TEXT_INFO messages */ + logStream << APPNAME << ": " << msg[i]->msg << endl; + break; + } + if (result != PAM_SUCCESS) + break; + } + + if (result != PAM_SUCCESS) + { + for (i = 0; i < num_msg; i++) + { + if ((*resp)[i].resp == 0) + continue; + free((*resp)[i].resp); + (*resp)[i].resp = 0; + } + free(*resp); + *resp = 0; + } + + return result; +} +#endif + +extern App* LoginApp; + +int xioerror(Display *disp) +{ + LoginApp->RestartServer(); + return 0; +} + +void CatchSignal(int sig) +{ + logStream << APPNAME << ": unexpected signal " << sig << endl; + + if (LoginApp->isServerStarted()) + LoginApp->StopServer(); + + LoginApp->RemoveLock(); + exit(ERR_EXIT); +} + +static volatile bool got_sigusr1 = false; +void User1Signal(int sig) +{ + got_sigusr1 = true; + signal(sig, User1Signal); +} + +App::App(int argc, char** argv) + : Dpy(NULL), ServerPID(-1), serverStarted(false), +#ifdef USE_PAM + pam(conv, static_cast(&LoginPanel)), +#endif + cfg(0), + firstlogin(true), daemonmode(false), force_nodaemon(false), + testing(false), tww(1280), twh(1024), +#ifdef USE_CONSOLEKIT + consolekit_support_enabled(true), +#endif + mcookiesize(32) /* Must be divisible by 4 */ +{ + int tmp; + mcookie = string(App::mcookiesize, 'a'); + char * win_size = 0; + + /* Parse command line + Note: we allow an arg for the -n option to handle "-nodaemon" as + originally quoted in the docs. However, the parser has never + checked the arg, so "-noddy" works exactly the same */ + while ((tmp = getopt(argc, argv, "c:vhsp:w:n::d")) != EOF) + { + switch (tmp) + { + case 'c': /* Config */ + if (optarg == NULL) + { + cerr << "The -c option requires an argument" << endl; + exit(ERR_EXIT); + } + if ( cfg != 0 ) + { + cerr << "The -c option can only be given once" << endl; + exit(ERR_EXIT); + } + cfg = new Cfg; + cfg->readConf(optarg); + break; + + case 'p': /* Test theme */ + testtheme = optarg; + testing = true; + if (testtheme == NULL) + { + cerr << "The -p option requires an argument" << endl; + exit(ERR_EXIT); + } + break; + + case 'w': /* Window size for theme test mode */ + if ( !testing ) + { + cerr << "The -w option is only valid after -p" << endl; + exit(ERR_EXIT); + } + win_size = optarg; + // Test for valid syntax later + break; + + case 'd': /* Daemon mode */ + daemonmode = true; + break; + + case 'n': /* Daemon mode */ + daemonmode = false; + force_nodaemon = true; + break; + + case 'v': /* Version */ + std::cout << APPNAME << " version " << VERSION << endl; + exit(OK_EXIT); + break; + +#ifdef USE_CONSOLEKIT + case 's': /* Disable consolekit support */ + consolekit_support_enabled = false; + break; +#endif + + case '?': /* Illegal option - getopt will have printed an error */ + std::cout << endl; + case 'h': /* Help */ + std::cout << "usage: " << APPNAME << " [option ...]" << endl + << "options:" << endl + << " -c /path/to/config select configuration file" << endl + << " -d daemon mode" << endl + << " -n no-daemon mode" << endl +#ifdef USE_CONSOLEKIT + << " -s start for systemd, disable consolekit support" << endl +#endif + << " -p /path/to/themedir preview theme" << endl + << " -w x size of window for preview" << endl + << " -h show this help" << endl + << " -v show version" << endl; + exit(OK_EXIT); + break; + } + } +#ifndef XNEST_DEBUG + if (getuid() != 0 && !testing) + { + logStream << APPNAME << ": only root can run this program" << endl; + exit(ERR_EXIT); + } +#endif /* XNEST_DEBUG */ + if ( win_size ) + { + char* sep = 0; + tww = (short)strtol ( win_size, &sep, 10 ); + if ( ( sep == 0 ) || ( *sep++ != 'x' ) ) + { + cerr << "Malformed argument to -w option" << endl; + exit(ERR_EXIT); + } + twh = (short)strtol ( sep, &sep, 10 ); + } +} + + +void App::Run() +{ + DisplayName = DISPLAY; + +#ifdef XNEST_DEBUG + char* p = getenv("DISPLAY"); + if (p && p[0]) + { + DisplayName = p; + cout << "Using display name " << DisplayName << endl; + } +#endif + + /* Read configuration and theme */ + if ( cfg == 0 ) + { + cfg = new Cfg; + cfg->readConf(CFGFILE); + } + string themebase = ""; + string themefile = ""; + string themedir = ""; + + if (testing) + { + themeName = testtheme; + } + else + { + themebase = string(THEMESDIR) + "/"; + themeName = cfg->getOption("current_theme"); + string::size_type pos; + if ((pos = themeName.find(",")) != string::npos) + { + /* input is a set */ + themeName = cfg->findValidRandomTheme(themeName); + if (themeName == "") + { + themeName = "default"; + } + } + } + +#ifdef USE_PAM + try { + pam.start("slim"); + pam.set_item(PAM::Authenticator::TTY, DisplayName); + pam.set_item(PAM::Authenticator::Requestor, "root"); + pam.setenv("XDG_SESSION_CLASS", "greeter"); // so eLogind works right + } + catch(PAM::Exception& e){ + logStream << APPNAME << ": " << e << endl; + exit(ERR_EXIT); + } +#endif + + bool loaded = false; + while (!loaded) + { + themedir = themebase + themeName; + themefile = themedir + THEMESFILE; + if (!cfg->readConf(themefile)) + { + if (themeName == "default") + { + logStream << APPNAME << ": Failed to open default theme file " + << themefile << endl; + exit(ERR_EXIT); + } + else + { + logStream << APPNAME << ": Invalid theme in config: " + << themeName << endl; + themeName = "default"; + } + } + else + { + loaded = true; + } + } + + if (!testing) + { + /* Create lock file */ + LoginApp->GetLock(); + + /* Start x-server */ + setenv("DISPLAY", DisplayName, 1); + signal(SIGQUIT, CatchSignal); + signal(SIGTERM, CatchSignal); + signal(SIGKILL, CatchSignal); + signal(SIGINT, CatchSignal); + signal(SIGHUP, CatchSignal); + signal(SIGPIPE, CatchSignal); + signal(SIGUSR1, User1Signal); + +#ifndef XNEST_DEBUG + if ( !force_nodaemon && cfg->getOption("daemon") == "yes" ) + { + daemonmode = true; + } + + /* Daemonize */ + if (daemonmode) + { + if (daemon(0, 0) == -1) + { + logStream << APPNAME << ": " << strerror(errno) << endl; + exit(ERR_EXIT); + } + } + + OpenLog(); + + if (daemonmode) + UpdatePid(); + + CreateServerAuth(); + StartServer(); +#endif + } + + /* Open display if we haven't already (e.g. testing) */ + if ( Dpy == 0 ) + Dpy = XOpenDisplay(DisplayName); + /* Now check that it succeeded */ + if ( Dpy == 0 ) + { + logStream << APPNAME << ": could not open display '" + << DisplayName << "'" << endl; +#ifndef XNEST_DEBUG + if (!testing) + StopServer(); +#endif + exit(ERR_EXIT); + } + + /* Get screen and root window */ + Scr = DefaultScreen(Dpy); + Root = RootWindow(Dpy, Scr); + + /* for tests we use a standard window */ + if (testing) + { + Window RealRoot = Root; // already done RootWindow(Dpy, Scr); + Root = XCreateSimpleWindow(Dpy, RealRoot, 0, 0, tww, twh, 0, 0, 0); + XMapWindow(Dpy, Root); + XFlush(Dpy); + } + else + { + blankScreen(); + } + + /* Create panel */ + LoginPanel = new Panel ( Dpy, Scr, Root, cfg, themedir, + ( testing ? Panel::Mode_Test : Panel::Mode_DM ) ); + LoginPanel->HideCursor(); + + bool firstloop = true; /* 1st time panel is shown (for automatic username) */ + bool focuspass = cfg->getOption("focus_password")=="yes"; + bool autologin = cfg->getOption("auto_login")=="yes"; + + if ( firstlogin && ( cfg->getOption("default_user") != "" ) ) + { + LoginPanel->SetName ( cfg->getOption("default_user") ); + firstlogin = false; +#ifdef USE_PAM + pam.set_item(PAM::Authenticator::User, cfg->getOption("default_user").c_str()); +#endif + if (autologin) + { +#ifdef USE_PAM + try { + pam.check_acct(); +#endif + Login(); +#ifdef USE_PAM + } + catch(PAM::Auth_Exception& e){ + // The default user is invalid + } +#endif + } + } + + /* Set NumLock */ + string numlock = cfg->getOption("numlock"); + if (numlock == "on") + NumLock::setOn(Dpy); + else if (numlock == "off") + NumLock::setOff(Dpy); + + + /* Start looping */ + int panelclosed = 1; + Panel::ActionType Action; + + while (1) + { + if (panelclosed) + { + /* Init root */ + LoginPanel->setBackground(); + + /* Close all clients */ + if (!testing) + { + KillAllClients(False); + KillAllClients(True); + } + + /* Show panel */ + LoginPanel->OpenPanel(); + } + + if ( firstloop ) + { + LoginPanel->Reset(); + + if ( cfg->getOption("default_user") != "" ) + LoginPanel->SetName(cfg->getOption("default_user")); + + // Removed by Gentoo "session-chooser" patch + //LoginPanel->SwitchSession(); + } + + if ( !AuthenticateUser(focuspass && firstloop) ) + { + unsigned int cfg_passwd_timeout; + cfg_passwd_timeout = Cfg::string2int(cfg->getOption("wrong_passwd_timeout").c_str()); + if ( cfg_passwd_timeout > 60 ) + cfg_passwd_timeout = 60; + panelclosed = 0; + firstloop = false; + LoginPanel->WrongPassword(cfg_passwd_timeout); + XBell(Dpy, 100); + continue; + } + + firstloop = false; + + Action = LoginPanel->getAction(); + /* for themes test we just quit */ + if ( testing ) + { + Action = Panel::Exit; + } + + panelclosed = 1; + LoginPanel->ClosePanel(); + + switch (Action) + { + case Panel::Login: + Login(); + break; + case Panel::Console: + Console(); + break; + case Panel::Reboot: + Reboot(); + break; + case Panel::Halt: + Halt(); + break; + case Panel::Suspend: + Suspend(); + break; + case Panel::Exit: + Exit(); + break; + default: + break; + } + } +} + +#ifdef USE_PAM +bool App::AuthenticateUser(bool focuspass) +{ + /* Reset the username */ + try{ + if (!focuspass) + pam.set_item(PAM::Authenticator::User, 0); + pam.authenticate(); + } + catch(PAM::Auth_Exception& e){ + switch (LoginPanel->getAction()) + { + case Panel::Exit: + case Panel::Console: + return true; /* <--- This is simply fake! */ + + default: + break; + } + logStream << APPNAME << ": " << e << endl; + return false; + } + catch(PAM::Exception& e){ + logStream << APPNAME << ": " << e << endl; + exit(ERR_EXIT); + } + return true; +} +#else +bool App::AuthenticateUser(bool focuspass) +{ + if (!focuspass) + { + LoginPanel->EventHandler(Panel::Get_Name); + switch (LoginPanel->getAction()) + { + case Panel::Exit: + case Panel::Console: + logStream << APPNAME << ": Got a special command (" + << LoginPanel->GetName() << ")" << endl; + return true; /* <--- This is simply fake! */ + + default: + break; + } + } + LoginPanel->EventHandler(Panel::Get_Passwd); + + char *encrypted, *correct; + struct passwd *pw; + + switch (LoginPanel->getAction()) + { + case Panel::Suspend: + case Panel::Halt: + case Panel::Reboot: + pw = getpwnam("root"); + break; + + case Panel::Console: + case Panel::Exit: + case Panel::Login: + pw = getpwnam(LoginPanel->GetName().c_str()); + break; + } + endpwent(); + if (pw == 0) + return false; + +#ifdef HAVE_SHADOW + struct spwd *sp = getspnam(pw->pw_name); + endspent(); + if (sp) + correct = sp->sp_pwdp; + else +#endif /* HAVE_SHADOW */ + correct = pw->pw_passwd; + + if (correct == 0 || correct[0] == '\0') + return true; + + encrypted = crypt(LoginPanel->GetPasswd().c_str(), correct); + return ((encrypted && strcmp(encrypted, correct) == 0) ? true : false); +} +#endif + +int App::GetServerPID() +{ + return ServerPID; +} + + +void App::Login() +{ + struct passwd *pw; + pid_t pid; + +#ifdef USE_PAM + try{ + pam.open_session(); + pw = getpwnam(static_cast(pam.get_item(PAM::Authenticator::User))); + } + catch(PAM::Cred_Exception& e){ + /* Credentials couldn't be established */ + logStream << APPNAME << ": " << e << endl; + return; + } + catch(PAM::Exception& e){ + logStream << APPNAME << ": " << e << endl; + exit(ERR_EXIT); + } +#else + pw = getpwnam(LoginPanel->GetName().c_str()); +#endif + endpwent(); + if (pw == 0) + return; + if (pw->pw_shell[0] == '\0') { + setusershell(); + strcpy(pw->pw_shell, getusershell()); + endusershell(); + } + + /* Setup the environment */ + char* term = getenv("TERM"); + string maildir = _PATH_MAILDIR; + maildir.append("/"); + maildir.append(pw->pw_name); + string xauthority = pw->pw_dir; + xauthority.append("/.Xauthority"); + +#ifdef USE_PAM + /* Setup the PAM environment */ + try{ + if (term) + pam.setenv("TERM", term); + pam.setenv("HOME", pw->pw_dir); + pam.setenv("PWD", pw->pw_dir); + pam.setenv("SHELL", pw->pw_shell); + pam.setenv("USER", pw->pw_name); + pam.setenv("LOGNAME", pw->pw_name); + pam.setenv("PATH", cfg->getOption("default_path").c_str()); + pam.setenv("DISPLAY", DisplayName); + pam.setenv("MAIL", maildir.c_str()); + pam.setenv("XAUTHORITY", xauthority.c_str()); + } + catch(PAM::Exception& e){ + logStream << APPNAME << ": " << e << endl; + exit(ERR_EXIT); + } +#endif + +#ifdef USE_CONSOLEKIT + if (consolekit_support_enabled) + { + /* Setup the ConsoleKit session */ + try { + ck.open_session(DisplayName, pw->pw_uid); + } + catch(Ck::Exception &e) { + logStream << APPNAME << ": " << e << endl; + exit(ERR_EXIT); + } + } +#endif + + /* Create new process */ + pid = fork(); + if (pid == 0) + { +#ifdef USE_PAM + /* Get a copy of the environment and close the child's copy */ + /* of the PAM-handle. */ + char** child_env = pam.getenvlist(); + +# ifdef USE_CONSOLEKIT + if (consolekit_support_enabled) + { + char** old_env = child_env; + + /* Grow the copy of the environment for the session cookie */ + int n; + for (n = 0; child_env[n] != NULL ; n++) + ; + + n++; + + child_env = static_cast(malloc(sizeof(char*)*(n+1))); + memcpy(child_env, old_env, sizeof(char*)*n); + child_env[n - 1] = StrConcat("XDG_SESSION_COOKIE=", ck.get_xdg_session_cookie()); + child_env[n] = NULL; + } +# endif /* USE_CONSOLEKIT */ +#else + +# ifdef USE_CONSOLEKIT + const int Num_Of_Variables = 12; /* Number of env. variables + 1 */ +# else + const int Num_Of_Variables = 11; /* Number of env. variables + 1 */ +# endif /* USE_CONSOLEKIT */ + char** child_env = static_cast(malloc(sizeof(char*)*Num_Of_Variables)); + int n = 0; + if (term) + child_env[n++]=StrConcat("TERM=", term); + child_env[n++]=StrConcat("HOME=", pw->pw_dir); + child_env[n++]=StrConcat("PWD=", pw->pw_dir); + child_env[n++]=StrConcat("SHELL=", pw->pw_shell); + child_env[n++]=StrConcat("USER=", pw->pw_name); + child_env[n++]=StrConcat("LOGNAME=", pw->pw_name); + child_env[n++]=StrConcat("PATH=", cfg->getOption("default_path").c_str()); + child_env[n++]=StrConcat("DISPLAY=", DisplayName); + child_env[n++]=StrConcat("MAIL=", maildir.c_str()); + child_env[n++]=StrConcat("XAUTHORITY=", xauthority.c_str()); +# ifdef USE_CONSOLEKIT + if (consolekit_support_enabled) + child_env[n++]=StrConcat("XDG_SESSION_COOKIE=", ck.get_xdg_session_cookie()); +# endif /* USE_CONSOLEKIT */ + child_env[n++]=0; + +#endif + + /* Login process starts here */ + SwitchUser Su(pw, cfg, DisplayName, child_env); + string session = LoginPanel->getSession(); + string loginCommand = cfg->getOption("login_cmd"); + replaceVariables(loginCommand, SESSION_VAR, session); + replaceVariables(loginCommand, THEME_VAR, themeName); + string sessStart = cfg->getOption("sessionstart_cmd"); + if (sessStart != "") + { + replaceVariables(sessStart, USER_VAR, pw->pw_name); + if ( system(sessStart.c_str()) < 0 ) + logStream << APPNAME << ": Failed to run sessionstart_cmd" << endl; + } + Su.Login(loginCommand.c_str(), mcookie.c_str()); + _exit(OK_EXIT); + } + +#ifndef XNEST_DEBUG + CloseLog(); +#endif + + /* Wait until user is logging out (login process terminates) */ + pid_t wpid = -1; + int status; + while (wpid != pid) + { + wpid = wait(&status); + if (wpid == ServerPID) + xioerror(Dpy); /* Server died, simulate IO error */ + } +#ifndef XNEST_DEBUG + /* Re-activate log file */ + OpenLog(); +#endif + if (WIFEXITED(status) && WEXITSTATUS(status)) + { + LoginPanel->Message("Failed to execute login command"); + sleep(3); + } + else + { + string sessStop = cfg->getOption("sessionstop_cmd"); + if ( sessStop != "" ) + { + replaceVariables ( sessStop, USER_VAR, pw->pw_name ); + if ( system(sessStop.c_str()) < 0 ) + logStream << APPNAME << "Session stop command failed" << endl; + } + } + +#ifdef USE_CONSOLEKIT + if (consolekit_support_enabled) + { + try { + ck.close_session(); + } + catch(Ck::Exception &e) { + logStream << APPNAME << ": " << e << endl; + } + } +#endif + +#ifdef USE_PAM + try { + pam.close_session(); + } + catch(PAM::Exception& e){ + logStream << APPNAME << ": " << e << endl; + } +#endif + +/* Close all clients */ + KillAllClients(False); + KillAllClients(True); + + /* Send HUP signal to clientgroup */ + killpg(pid, SIGHUP); + + /* Send TERM signal to clientgroup, if error send KILL */ + if (killpg(pid, SIGTERM)) + killpg(pid, SIGKILL); + + LoginPanel->HideCursor(); + +#ifndef XNEST_DEBUG + RestartServer(); /// @bug recursive call! +#endif +} + + +void App::Reboot() +{ +#ifdef USE_PAM + try { + pam.end(); + } + catch(PAM::Exception& e){ + logStream << APPNAME << ": " << e << endl; + } +#endif + + /* Write message */ + LoginPanel->Message((char*)cfg->getOption("reboot_msg").c_str()); + sleep(3); + + /* Stop server and reboot */ + StopServer(); + RemoveLock(); + if ( system(cfg->getOption("reboot_cmd").c_str()) < 0 ) + logStream << APPNAME << ": Failed to execute reboot command" << endl; + exit(OK_EXIT); +} + + +void App::Halt() +{ +#ifdef USE_PAM + try { + pam.end(); + } + catch(PAM::Exception& e){ + logStream << APPNAME << ": " << e << endl; + } +#endif + + /* Write message */ + LoginPanel->Message((char*)cfg->getOption("shutdown_msg").c_str()); + sleep(3); + + /* Stop server and halt */ + StopServer(); + RemoveLock(); + if ( system(cfg->getOption("halt_cmd").c_str()) < 0 ) + logStream << APPNAME << ": Failed to execute halt command" << endl; + exit(OK_EXIT); +} + + +void App::Suspend() +{ + sleep(1); + if ( system(cfg->getOption("suspend_cmd").c_str() ) < 0 ) + logStream << APPNAME << ": Failed to execute suspend command" << endl; +} + + +void App::Console() +{ + int posx = 40; + int posy = 40; + int fontx = 9; + int fonty = 15; + int width = (XWidthOfScreen(ScreenOfDisplay(Dpy, Scr)) - (posx * 2)) / fontx; + int height = (XHeightOfScreen(ScreenOfDisplay(Dpy, Scr)) - (posy * 2)) / fonty; + + /* Execute console */ + const char* cmd = cfg->getOption("console_cmd").c_str(); + char *tmp = new char[strlen(cmd) + 60]; + sprintf(tmp, cmd, width, height, posx, posy, fontx, fonty); + if ( system(tmp) < 0 ) + logStream << APPNAME << ": Failed to fork console app '" << cmd << "'" << endl; + delete [] tmp; +} + +void App::Exit() +{ +#ifdef USE_PAM + try { + pam.end(); + } + catch(PAM::Exception& e){ + logStream << APPNAME << ": " << e << endl; + } +#endif + + if (testing) + { + std::string testmsg = "User "; + testmsg += LoginPanel->GetName(); + testmsg += " auth OK, session="; + testmsg += LoginPanel->getSession(); + LoginPanel->Message(testmsg); + sleep(3); + delete LoginPanel; + XCloseDisplay(Dpy); + } + else + { + delete LoginPanel; + StopServer(); + RemoveLock(); + } + delete cfg; + exit(OK_EXIT); +} + +int CatchErrors(Display *dpy, XErrorEvent *ev) +{ + return 0; +} + +void App::RestartServer() +{ +#ifdef USE_PAM + try { + pam.end(); + } + catch(PAM::Exception& e){ + logStream << APPNAME << ": " << e << endl; + } +#endif + + StopServer(); + RemoveLock(); + if (force_nodaemon) + { + delete LoginPanel; + exit(ERR_EXIT); /* use ERR_EXIT so that systemd's RESTART=on-failure works */ + } + else + { + while (waitpid(-1, NULL, WNOHANG) > 0); /* Collects all dead children */ + Run(); + } +} + + +/* + * Iterates over the list of all windows declared as children of Root and + * kills the clients. Since Root is the root window of the screen, all + * running applications (of the logged-in session) should be caught by this + */ +void App::KillAllClients(Bool top) +{ + Window dummywindow; + Window *children; + unsigned int nchildren; + unsigned int i; + XWindowAttributes attr; + + XSync(Dpy, 0); + XSetErrorHandler(CatchErrors); + + nchildren = 0; + XQueryTree(Dpy, Root, &dummywindow, &dummywindow, &children, &nchildren); + if (!top) + { + for (i=0; i timeout) + break; + } + + if (i > 0) + logStream << endl; + lasttext = text; + + return (ServerPID != pidfound); +} + + +int App::WaitForServer() +{ + int ncycles = 120; + int cycles; + + /* The X server should send us a USR1 signal when it's ready. We trap */ + /* that signal and set a flag. If that's not already happened, wait for */ + /* a good time. The incoming signal should terminate the sleep() call */ + /* with a non-zero return value. Otherwise, time out and try anyway but */ + /* log the oddity. */ + if ( !got_sigusr1 && ( sleep(5)==0 ) ) + logStream << "WaitForServer: Not seen SigUSR1 from Xserver" << endl; + + for (cycles = 0; cycles < ncycles; cycles++) + { + Dpy = XOpenDisplay(DisplayName); + if ( Dpy ) + { + XSetIOErrorHandler(xioerror); + return 1; + } + else + { + if (!ServerTimeout(1, (char *) "X server to begin accepting connections")) + break; + } + } + + logStream << "Giving up." << endl; + + return 0; +} + +int App::StartServer() +{ + got_sigusr1 = false; // We're about to start the X server so clear the semaphore + + ServerPID = fork(); /// @bug why do this so early? Just before the switch makes more sense + + int argc = 1, pos = 0, i; + static const int MAX_XSERVER_ARGS = 256; + static char* server[MAX_XSERVER_ARGS+2] = { NULL }; + server[0] = (char *)cfg->getOption("default_xserver").c_str(); + string argOption = cfg->getOption("xserver_arguments"); + /* Add mandatory -xauth option */ + argOption = argOption + " -auth " + cfg->getOption("authfile"); + char* args = new char[argOption.length()+2]; /* NULL plus vt */ + strcpy(args, argOption.c_str()); + + serverStarted = false; + + bool hasVtSet = false; + while (args[pos] != '\0') + { + if (args[pos] == ' ' || args[pos] == '\t') + { + *(args+pos) = '\0'; + server[argc++] = args+pos+1; + } + else if (pos == 0) + { + server[argc++] = args+pos; + } + ++pos; + + if (argc+1 >= MAX_XSERVER_ARGS) + { + /* ignore _all_ arguments to make sure the server starts at */ + /* all */ + argc = 1; + break; + } + } + + for (i = 0; i < argc; i++) + { + if (server[i][0] == 'v' && server[i][1] == 't') + { + bool ok = false; + Cfg::string2int(server[i]+2, &ok); + if (ok) + { + hasVtSet = true; + } + } + } + + if (!hasVtSet && daemonmode) + { + server[argc++] = (char*)"vt07"; + } + server[argc] = NULL; + + switch (ServerPID) { + case 0: + signal(SIGTTIN, SIG_IGN); + signal(SIGTTOU, SIG_IGN); + signal(SIGUSR1, SIG_IGN); + setpgid(0,getpid()); + + execvp(server[0], server); + logStream << APPNAME << ": X server could not be started" << endl; + exit(ERR_EXIT); + break; + + case -1: + break; + + default: + errno = 0; + // Prime the server timeout function and check for an immediate crash + if (!ServerTimeout(0, (char *)"")) + { + ServerPID = -1; + break; + } + + /* Wait for server to start up */ + if (WaitForServer() == 0) + { + logStream << APPNAME << ": unable to connect to X server" << endl; + StopServer(); + ServerPID = -1; + exit(ERR_EXIT); + } + break; + } + + delete [] args; + + serverStarted = true; ///< @bug not true if ServerPID is -1 + + return ServerPID; +} + + +jmp_buf CloseEnv; +int IgnoreXIO(Display *d) +{ + logStream << APPNAME << ": connection to X server lost." << endl; + longjmp(CloseEnv, 1); +} + +void App::StopServer() +{ + signal(SIGQUIT, SIG_IGN); + signal(SIGINT, SIG_IGN); + signal(SIGHUP, SIG_IGN); + signal(SIGPIPE, SIG_IGN); + signal(SIGTERM, SIG_DFL); + signal(SIGKILL, SIG_DFL); + + /* Catch X error */ + XSetIOErrorHandler(IgnoreXIO); + if (!setjmp(CloseEnv) && Dpy) + XCloseDisplay(Dpy); + + /* Send HUP to process group */ + errno = 0; + if ((killpg(getpid(), SIGHUP) != 0) && (errno != ESRCH)) + logStream << APPNAME << ": can't send HUP to process group " << getpid() << endl; + + /* Send TERM to server */ + if (ServerPID < 0) + return; + + errno = 0; + + if (killpg(ServerPID, SIGTERM) < 0) + { + if (errno == EPERM) + { + logStream << APPNAME << ": can't kill X server" << endl; + exit(ERR_EXIT); + } + if (errno == ESRCH) + return; + } + + /* Wait for server to shut down */ + if (!ServerTimeout(10, (char *)"X server to shut down")) + { + logStream << endl; + return; + } + + logStream << endl << APPNAME << + ": X server slow to shut down, sending KILL signal." << endl; + + /* Send KILL to server */ + errno = 0; + if (killpg(ServerPID, SIGKILL) < 0) + { + if (errno == ESRCH) + return; + } + + /* Wait for server to die */ + if (ServerTimeout(3, (char*)"server to die")) + { + logStream << endl << APPNAME << ": can't kill server" << endl; + exit(ERR_EXIT); + } + logStream << endl; +} + +void App::blankScreen() +{ + GC gc = XCreateGC(Dpy, Root, 0, 0); + XSetForeground(Dpy, gc, BlackPixel(Dpy, Scr)); + XFillRectangle(Dpy, Root, gc, 0, 0, + XWidthOfScreen(ScreenOfDisplay(Dpy, Scr)), + XHeightOfScreen(ScreenOfDisplay(Dpy, Scr))); + XFlush(Dpy); + XFreeGC(Dpy, gc); +} + + +/* Check if there is a lockfile and a corresponding process */ +void App::GetLock() +{ + std::ifstream lockfile(cfg->getOption("lockfile").c_str()); + if (!lockfile) + { + /* no lockfile present, create one */ + std::ofstream lockfile(cfg->getOption("lockfile").c_str(), ios_base::out); + if (!lockfile) + { + logStream << APPNAME << ": Could not create lock file: " << + cfg->getOption("lockfile").c_str() << std::endl; + exit(ERR_EXIT); + } + lockfile << getpid() << std::endl; + lockfile.close(); + } + else + { + /* lockfile present, read pid from it */ + int pid = 0; + lockfile >> pid; + lockfile.close(); + if (pid > 0) + { + /* see if process with this pid exists */ + int ret = kill(pid, 0); + if (ret == 0 || (ret == -1 && errno == EPERM) ) + { + logStream << APPNAME << + ": Another instance of the program is already running with PID " + << pid << std::endl; + exit(0); + } + else + { + logStream << APPNAME << ": Stale lockfile found, removing it" << std::endl; + std::ofstream lockfile(cfg->getOption("lockfile").c_str(), ios_base::out); + if (!lockfile) + { + logStream << APPNAME << + ": Could not create new lock file: " << cfg->getOption("lockfile") + << std::endl; + exit(ERR_EXIT); + } + lockfile << getpid() << std::endl; + lockfile.close(); + } + } + } +} + + +/* Remove lockfile */ +void App::RemoveLock() +{ + remove(cfg->getOption("lockfile").c_str()); +} + + +/* Get server start check flag. */ +bool App::isServerStarted() +{ + return serverStarted; +} + + +/* Open a log file for error reporting */ +void App::OpenLog() +{ + if ( !logStream.openLog( cfg->getOption("logfile").c_str() ) ) + { + cerr << APPNAME << ": Could not access log file: " << cfg->getOption("logfile") << endl; + RemoveLock(); + exit(ERR_EXIT); + } + /* I should set the buffers to imediate write, but I just flush on every << operation. */ +} + + +/* Close the logging stream - just a wrapper round the real method */ +void App::CloseLog() +{ + /* Simply closing the log */ + logStream.closeLog(); +} + + +/* + * Populate any matching fields in a markup string with the value of + * a variable. The markup is %name but that is not enforced here - instead + * the caller must pass the full markup tag - %name, not just name + */ +void App::replaceVariables(string& input, + const string& var, + const string& value) +{ + string::size_type pos = 0; + int len = var.size(); + while ((pos = input.find(var, pos)) != string::npos) { + input = input.substr(0, pos) + value + input.substr(pos+len); + } +} + + +/* + * Set the required server authority parameters in the environment + * and file system. + */ +void App::CreateServerAuth() +{ + /* create mit cookie */ + uint16_t word; + uint8_t hi, lo; + int i; + string authfile; + const char *digits = "0123456789abcdef"; + Util::srandom(Util::makeseed()); + for (i = 0; i < App::mcookiesize; i+=4) + { + /* We rely on the fact that all bits generated by Util::random() + * are usable, so we are taking full words from its output. */ + word = Util::random() & 0xffff; + lo = word & 0xff; + hi = word >> 8; + mcookie[i] = digits[lo & 0x0f]; + mcookie[i+1] = digits[lo >> 4]; + mcookie[i+2] = digits[hi & 0x0f]; + mcookie[i+3] = digits[hi >> 4]; + } + /* reinitialize auth file */ + authfile = cfg->getOption("authfile"); + remove(authfile.c_str()); + putenv(StrConcat("XAUTHORITY=", authfile.c_str())); + Util::add_mcookie(mcookie, ":0", cfg->getOption("xauth_path"), + authfile); +} + + +/* + * Concatenate two C-style strings into a newly alloc'd char array of the + * right size. + */ +char* App::StrConcat(const char* str1, const char* str2) +{ + char* tmp = new char[strlen(str1) + strlen(str2) + 1]; + strcpy(tmp, str1); + strcat(tmp, str2); + return tmp; +} + + +/* + * Write our process ID to the lock file specified in the config + */ +void App::UpdatePid() +{ + std::ofstream lockfile(cfg->getOption("lockfile").c_str(), ios_base::out); + if (!lockfile) { + logStream << APPNAME << ": Could not update lock file: " << + cfg->getOption("lockfile").c_str() << endl; + exit(ERR_EXIT); + } + lockfile << getpid() << endl; + lockfile.close(); +} + diff --git a/slim/app.h b/slim/app.h new file mode 100644 index 0000000..e0b9230 --- /dev/null +++ b/slim/app.h @@ -0,0 +1,115 @@ +/* SLiM - Simple Login Manager + * Copyright (C) 1997, 1998 Per Liden + * Copyright (C) 2004-06 Simone Rota + * Copyright (C) 2004-06 Johannes Winkelmann + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + */ + +#ifndef _APP_H_ +#define _APP_H_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include "panel.h" +#include "cfg.h" +#include "image.h" + +#ifdef USE_PAM +#include "PAM.h" +#endif +#ifdef USE_CONSOLEKIT +#include "Ck.h" +#endif + +class App +{ +public: + App(int argc, char **argv); + ~App(); + void Run(); + int GetServerPID(); + void RestartServer(); + void StopServer(); + + /* Lock functions */ + void GetLock(); + void RemoveLock(); + + bool isServerStarted(); + +private: + void Login(); + void Reboot(); + void Halt(); + void Suspend(); + void Console(); + void Exit(); + void KillAllClients(Bool top); + void ReadConfig(); + void OpenLog(); + void CloseLog(); + void CreateServerAuth(); + char *StrConcat(const char *str1, const char *str2); + void UpdatePid(); + + bool AuthenticateUser(bool focuspass); + + static void replaceVariables(std::string &input, + const std::string &var, + const std::string &value); + + /* Server functions */ + int StartServer(); + int ServerTimeout(int timeout, char *string); + int WaitForServer(); + + /* Private data */ + Window Root; ///< The root window of the default screen, on which to draw + Display *Dpy; ///< Connection to the X-server + int Scr; ///< Which "screen" to use (which will be the default one) + Panel *LoginPanel; ///< The panel we display and interact through + int ServerPID; ///< Process ID of the X-server we launched + const char *DisplayName; ///< The display to request, usually ":0.0" + bool serverStarted; ///< Whether we (think we) have started an X server + +#ifdef USE_PAM + PAM::Authenticator pam; ///< Interface to the PAM authentication library +#endif +#ifdef USE_CONSOLEKIT + Ck::Session ck; ///< Interface to ConsoleKit, if used +#endif + + /* Options */ + Cfg *cfg; ///< Collection of options from the configuration file + + void blankScreen(); + + bool firstlogin; ///< Whether to exhibit first login behaviour, or repeat + bool daemonmode; ///< Are we running as a daemon? + bool force_nodaemon; ///< Are we forced NOT to be a daemon? + /* For testing themes */ + char *testtheme; ///< Name of the theme to test, from command line + bool testing; ///< Whether we're running in theme testing mode + short tww, twh; ///< The user's requested test window size + +#ifdef USE_CONSOLEKIT + bool consolekit_support_enabled; ///< Whether to use ConsoleKit (not compatible with systemd) +#endif + + std::string themeName; ///< Name of the theme in use + std::string mcookie; ///< Randomly generated X auth cookie + + const int mcookiesize; +}; + +#endif /* _APP_H_ */ diff --git a/slim/cfg.cpp b/slim/cfg.cpp new file mode 100644 index 0000000..37fb10d --- /dev/null +++ b/slim/cfg.cpp @@ -0,0 +1,478 @@ +/* SLiM - Simple Login Manager + * Copyright (C) 2004-06 Simone Rota + * Copyright (C) 2004-06 Johannes Winkelmann + * Copyright (C) 2012-13 Nobuhiro Iwamatsu + * Copyright (C) 2022-23 Rob Pearce + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + */ + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "util.h" // for Util::random +#include "log.h" // for logStream + +#include "cfg.h" + +using namespace std; + +typedef pair option; + +/** + * Constructor: creates the Cfg object and populates the available options + * with default values. + */ +Cfg::Cfg() + : currentSession(-1) +{ + /* Configuration options */ + options.insert(option("default_path","/bin:/usr/bin:/usr/local/bin")); + options.insert(option("default_xserver","/usr/bin/X")); + options.insert(option("xserver_arguments","")); + options.insert(option("numlock","")); + options.insert(option("daemon","")); + options.insert(option("xauth_path","/usr/bin/xauth")); + options.insert(option("login_cmd","exec /bin/bash -login ~/.xinitrc %session")); + options.insert(option("halt_cmd","/sbin/shutdown -h now")); + options.insert(option("reboot_cmd","/sbin/shutdown -r now")); + options.insert(option("suspend_cmd","")); + options.insert(option("sessionstart_cmd","")); + options.insert(option("sessionstop_cmd","")); + options.insert(option("console_cmd","/usr/bin/xterm -C -fg white -bg black +sb -g %dx%d+%d+%d -fn %dx%d -T ""Console login"" -e /bin/sh -c ""/bin/cat /etc/issue; exec /bin/login""")); + options.insert(option("screenshot_cmd","import -window root /slim.png")); + options.insert(option("default_user","")); + options.insert(option("focus_password","no")); + options.insert(option("auto_login","no")); + options.insert(option("current_theme","default")); + options.insert(option("lockfile","/var/run/slim.lock")); + options.insert(option("logfile","/var/log/slim.log")); + options.insert(option("authfile","/var/run/slim.auth")); + options.insert(option("shutdown_msg","The system is halting...")); + options.insert(option("reboot_msg","The system is rebooting...")); + options.insert(option("sessions", "")); + options.insert(option("sessiondir","")); + options.insert(option("hidecursor","false")); + + /* Theme stuff */ + options.insert(option("background_style","stretch")); + options.insert(option("background_color","#CCCCCC")); + + options.insert(option("input_panel_x","50%")); /* Panel position on screen */ + options.insert(option("input_panel_y","40%")); + options.insert(option("input_font","Verdana:size=11")); + options.insert(option("input_color", "#000000")); + options.insert(option("input_shadow_xoffset", "0")); + options.insert(option("input_shadow_yoffset", "0")); + options.insert(option("input_shadow_color","#FFFFFF")); + options.insert(option("input_name_x","200")); /* relative to panel */ + options.insert(option("input_name_y","154")); + options.insert(option("input_pass_x","-1")); /* default is single inputbox */ + options.insert(option("input_pass_y","-1")); + + options.insert(option("welcome_msg","Welcome to %host")); + options.insert(option("welcome_font","Verdana:size=14")); + options.insert(option("welcome_color","#FFFFFF")); + options.insert(option("welcome_x","-1")); + options.insert(option("welcome_y","-1")); + options.insert(option("welcome_shadow_xoffset", "0")); + options.insert(option("welcome_shadow_yoffset", "0")); + options.insert(option("welcome_shadow_color","#FFFFFF")); + + options.insert(option("username_msg","Please enter your username")); + options.insert(option("username_font","Verdana:size=12")); + options.insert(option("username_color","#FFFFFF")); + options.insert(option("username_x","-1")); + options.insert(option("username_y","-1")); + options.insert(option("username_shadow_xoffset", "0")); + options.insert(option("username_shadow_yoffset", "0")); + options.insert(option("username_shadow_color","#FFFFFF")); + + options.insert(option("password_msg","Please enter your password")); + options.insert(option("password_x","-1")); + options.insert(option("password_y","-1")); + + options.insert(option("msg_font","Verdana:size=16:bold")); + options.insert(option("msg_color","#FFFFFF")); + options.insert(option("msg_x","40")); + options.insert(option("msg_y","40")); + options.insert(option("msg_shadow_xoffset", "0")); + options.insert(option("msg_shadow_yoffset", "0")); + options.insert(option("msg_shadow_color","#FFFFFF")); + + options.insert(option("session_msg","Session:")); + options.insert(option("session_font","Verdana:size=16:bold")); + options.insert(option("session_color","#FFFFFF")); + options.insert(option("session_x","50%")); + options.insert(option("session_y","90%")); + options.insert(option("session_shadow_xoffset", "0")); + options.insert(option("session_shadow_yoffset", "0")); + options.insert(option("session_shadow_color","#FFFFFF")); + + // What to do if the authorisation fails + options.insert(option("keep_user_on_fail", "0")); + options.insert(option("wrong_passwd_timeout", "2")); + options.insert(option("passwd_feedback_msg", "Authentication failed")); + options.insert(option("passwd_feedback_capslock", "Authentication failed (CapsLock is on)")); + options.insert(option("passwd_feedback_x", "-1")); /* no feedback by default */ + options.insert(option("passwd_feedback_y", "-1")); + options.insert(option("bell", "0")); + + // slimlock-specific options + options.insert(option("dpms_standby_timeout", "60")); + options.insert(option("dpms_off_timeout", "600")); + options.insert(option("show_username", "1")); + options.insert(option("show_welcome_msg", "0")); + options.insert(option("tty_lock", "1")); + + error = ""; +} + +Cfg::~Cfg() +{ + options.clear(); +} + +/** + * Parses known options from the given configfile / themefile + * + * @param configfile Path to configuration or theme + * @return true on sucess, false if file not found + */ +bool Cfg::readConf(string configfile) +{ + int n = -1; + size_t pos = 0; + string line, next, op, fn(configfile); + map::iterator it; + ifstream cfgfile(fn.c_str()); + + if (!cfgfile) + { + error = "Cannot read configuration file: " + configfile; + return false; + } + while (getline(cfgfile, line)) + { + // New parser to fix ticket #4 + pos = line.length(); + if ( ( pos > 0 ) && ( line[pos-1] == '\\' ) ) + { + line.replace ( pos-1, 1, " " ); + next = next + line; + continue; + } + + if ( !next.empty() ) + { + line = next + line; + next = ""; + } + + // Ignore blank lines and comment lines + if ( line.empty() || line[0] == '#' ) + continue; + + // Now parse and assign + if ( !parseOption ( line ) ) + cerr << error << '\n'; // not a fatal error + } + cfgfile.close(); + + fillSessionList(); + + return true; +} + +/** + * Sets an option value from a line. Returns true on success. + */ +bool Cfg::parseOption ( string line ) +{ + size_t pos = 0; + const string delims = " \t"; + string name, value; + + // First split the line into a name/value pair + pos = line.find_first_of ( delims ); + if ( pos == string::npos ) + { + error = "Badly formed line: " + line; + return false; + } + name = line.substr ( 0, pos ); + value = Trim ( line.substr ( pos ) ); + if ( value.empty() ) + { + error = "Badly formed line: " + line; + return false; + } + + // Look to see if it's a known option + if ( options.find ( name ) == options.end() ) + { + error = "Unknown option name: " + name; + return false; + } + // finally assign it + options[name] = value; + return true; +} + + +const string& Cfg::getError() const +{ + return error; +} + +string& Cfg::getOption(string option) +{ + return options[option]; +} + +/* return a trimmed string */ +string Cfg::Trim( const string& s ) +{ + if ( s.empty() ) { + return s; + } + int pos = 0; + string line = s; + int len = line.length(); + while ( pos < len && isspace( line[pos] ) ) { + ++pos; + } + line.erase( 0, pos ); + pos = line.length()-1; + while ( pos > -1 && isspace( line[pos] ) ) { + --pos; + } + if ( pos != -1 ) { + line.erase( pos+1 ); + } + return line; +} + +/* Return the welcome message with replaced vars */ +string Cfg::getWelcomeMessage() +{ + string s = getOption("welcome_msg"); + int n = s.find("%host"); + if (n >= 0) { + string tmp = s.substr(0, n); + char host[40]; + gethostname(host,40); + tmp = tmp + host; + tmp = tmp + s.substr(n+5, s.size() - n); + s = tmp; + } + n = s.find("%domain"); + if (n >= 0) { + string tmp = s.substr(0, n); + char domain[40]; + if ( getdomainname(domain,40) == 0 ) + tmp = tmp + domain; + else + tmp = tmp + ""; + tmp = tmp + s.substr(n+7, s.size() - n); + s = tmp; + } + return s; +} + +int Cfg::string2int(const char* string, bool* ok) +{ + char* err = 0; + int l = (int)strtol(string, &err, 10); + if (ok) { + *ok = (*err == 0); + } + return (*err == 0) ? l : 0; +} + +int Cfg::getIntOption(std::string option) +{ + return string2int(options[option].c_str()); +} + + +/** + * Get absolute position + * + * Converts a config position string into absolute coordinates. If the string + * is a plain number, this is just an atoi but if there is a percentage sign + * then the value is converted using the size of the canvas and the object. + * + * @param position Configured position as a string + * @param max Size of canvas in the relevant axis + * @param width Size of the object being placed + * @return Absolute coordinate to achieve placement + */ +int Cfg::absolutepos(const string& position, int max, int width) +{ + int n = position.find("%"); + if (n>0) { /* X Position expressed in percentage */ + int result = (max*string2int(position.substr(0, n).c_str())/100) - (width / 2); + return result < 0 ? 0 : result ; + } else { /* Absolute X position */ + return string2int(position.c_str()); + } +} + +/* split a comma separated string into a vector of strings */ +void Cfg::split(vector& v, const string& str, char c, bool useEmpty) +{ + v.clear(); + string::const_iterator s = str.begin(); + string tmp; + while (true) { + string::const_iterator begin = s; + while (*s != c && s != str.end()) + { + ++s; + } + tmp = string(begin, s); + if (useEmpty || tmp.size() > 0) + v.push_back(tmp); + if (s == str.end()) { + break; + } + if (++s == str.end()) { + if (useEmpty) + v.push_back(""); + break; + } + } +} + +void Cfg::fillSessionList() +{ + string strSessionList = getOption("sessions"); + string strSessionDir = getOption("sessiondir"); + + sessions.clear(); + + if ( !strSessionDir.empty() ) + { + DIR *pDir = opendir(strSessionDir.c_str()); + + if (pDir != NULL) { + struct dirent *pDirent = NULL; + + while ((pDirent = readdir(pDir)) != NULL) { + string strFile(strSessionDir); + strFile += "/"; + strFile += pDirent->d_name; + + struct stat oFileStat; + + if (stat(strFile.c_str(), &oFileStat) == 0) { + if (S_ISREG(oFileStat.st_mode) && + access(strFile.c_str(), R_OK) == 0){ + ifstream desktop_file(strFile.c_str()); + if (desktop_file){ + string line, session_name = "", session_exec = ""; + while (getline( desktop_file, line )) { + if (line.substr(0, 5) == "Name=") { + session_name = line.substr(5); + if (!session_exec.empty()) + break; + } + else if (line.substr(0, 5) == "Exec=") { + session_exec = line.substr(5); + if (!session_name.empty()) + break; + } + } + desktop_file.close(); + if (!session_name.empty() && !session_exec.empty()) { + pair session(session_name,session_exec); + sessions.push_back(session); + } else if (access(strFile.c_str(), X_OK) == 0) { + pair session(string(pDirent->d_name),strFile); + sessions.push_back(session); + } + } + } + } + } + closedir(pDir); + } + } + + if (sessions.empty()) + { + if (strSessionList.empty()) + { + pair session("",""); + sessions.push_back(session); + } + else + { + // iterate through the split of the session list + vector sessit; + split(sessit,strSessionList,',',false); + for (vector::iterator it = sessit.begin(); it != sessit.end(); ++it) + { + pair session(*it,*it); + sessions.push_back(session); + } + } + } +} + + +pair Cfg::nextSession() +{ + currentSession = (currentSession + 1) % sessions.size(); + return sessions[currentSession]; +} + + +/* + * Choose a theme at random from the list in the config file. IF the theme + * file cannot be found then issue a warning and try again. + */ +string Cfg::findValidRandomTheme ( const string& set ) +{ + /* extract random theme from theme set; return empty string on error */ + string name = set; + struct stat buf; + + if (name[name.length()-1] == ',') + { + name.erase(name.length() - 1); + } + + Util::srandom(Util::makeseed()); + + vector themes; + string themefile; + Cfg::split(themes, name, ','); + do { + int sel = Util::random() % themes.size(); + + name = Cfg::Trim(themes[sel]); + themefile = string(THEMESDIR) +"/" + name + THEMESFILE; + if (stat(themefile.c_str(), &buf) != 0) + { + themes.erase(find(themes.begin(), themes.end(), name)); + logStream << APPNAME << ": Invalid theme in config: " + << name << endl; + name = ""; + } + } while (name == "" && themes.size()); + return name; +} + diff --git a/slim/cfg.h b/slim/cfg.h new file mode 100644 index 0000000..f258908 --- /dev/null +++ b/slim/cfg.h @@ -0,0 +1,58 @@ +/* SLiM - Simple Login Manager + Copyright (C) 2004-06 Simone Rota + Copyright (C) 2004-06 Johannes Winkelmann + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +*/ + +#ifndef _CFG_H_ +#define _CFG_H_ + +#include +#include +#include + +#define INPUT_MAXLENGTH_NAME 30 +#define INPUT_MAXLENGTH_PASSWD 50 + +#define CFGFILE SYSCONFDIR"/slim.conf" +#define THEMESDIR PKGDATADIR"/themes" +#define THEMESFILE "/slim.theme" + +class Cfg +{ + +public: + Cfg(); + ~Cfg(); + + bool readConf(std::string configfile); + bool parseOption ( std::string line ); + const std::string& getError() const; + std::string& getOption(std::string option); + int getIntOption(std::string option); + std::string getWelcomeMessage(); + + static int absolutepos(const std::string &position, int max, int width); + static int string2int(const char *string, bool *ok = 0); + static void split(std::vector &v, const std::string &str, + char c, bool useEmpty=true); + static std::string Trim(const std::string &s); + + std::pair nextSession(); + static std::string findValidRandomTheme(const std::string &set); + +private: + void fillSessionList(); + +private: + std::map options; + std::vector > sessions; + int currentSession; + std::string error; +}; + +#endif /* _CFG_H_ */ diff --git a/slim/cmake/modules/FONTCONFIGConfig.cmake b/slim/cmake/modules/FONTCONFIGConfig.cmake new file mode 100644 index 0000000..60128c4 --- /dev/null +++ b/slim/cmake/modules/FONTCONFIGConfig.cmake @@ -0,0 +1,71 @@ +# +# Find the native FONTCONFIG includes and library +# + +# This module defines +# FONTCONFIG_INCLUDE_DIR, where to find art*.h etc +# FONTCONFIG_LIBRARY, the libraries to link against to use FONTCONFIG. +# FONTCONFIG_FOUND, If false, do not try to use FONTCONFIG. +# LIBFONTCONFIG_LIBS, link information +# LIBFONTCONFIG_CFLAGS, cflags for include information + +IF (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} LESS 2.5) + INCLUDE(UsePkgConfig) + PKGCONFIG(fontconfig _fontconfigIncDir _fontconfigLinkDir _fontconfigLinkFlags _fontconfigCflags) + SET(FONTCONFIG_LIBS ${_fontconfigCflags}) +ELSE (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} LESS 2.5) + INCLUDE(FindPkgConfig) + pkg_search_module(FONTCONFIG REQUIRED fontconfig) +ENDIF (${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} LESS 2.5) + +#INCLUDE(UsePkgConfig) + +# use pkg-config to get the directories and then use these values +# in the FIND_PATH() and FIND_LIBRARY() calls +#PKGCONFIG(fontconfig _fontconfigIncDir _fontconfigLinkDir _fontconfigLinkFlags _fontconfigCflags) + +#SET(FONTCONFIG_LIBS ${_fontconfigCflags}) + +IF(BUILD_OSX_BUNDLE) + FIND_PATH(FONTCONFIG_INCLUDE_DIR + NAMES fontconfig/fontconfig.h + PATHS ${FONTCONFIG_INCLUDE_DIRS} /opt/local/include + NO_DEFAULT_PATH + ) + FIND_LIBRARY(FONTCONFIG_LIBRARY + NAMES fontconfig + PATHS ${FONTCONFIG_LIBRARY_DIRS} /opt/local/lib + NO_DEFAULT_PATH + ) +ELSE(BUILD_OSX_BUNDLE) + FIND_PATH(FONTCONFIG_INCLUDE_DIR + NAMES fontconfig/fontconfig.h + PATHS ${FONTCONFIG_INCLUDE_DIRS} + ${_fontconfigIncDir} + /usr/include + /usr/local/include + PATH_SUFFIXES fontconfig + ) + # quick hack as the above finds it nicely but our source includes the libart_lgpl text at the moment + #STRING(REGEX REPLACE "/libart_lgpl" "" FONTCONFIG_INCLUDE_DIR ${FONTCONFIG_INCLUDE_DIR}) + FIND_LIBRARY(FONTCONFIG_LIBRARY NAMES fontconfig + PATHS ${FONTCONFIG_LIBRARY_DIRS} /usr/lib /usr/local/lib + ) +ENDIF(BUILD_OSX_BUNDLE) + + +# MESSAGE(STATUS "fclib ${FONTCONFIG_LIBRARY}") +# MESSAGE(STATUS "fcinclude ${FONTCONFIG_INCLUDE_DIR}") + + +IF (FONTCONFIG_LIBRARY) + IF (FONTCONFIG_INCLUDE_DIR) + SET( FONTCONFIG_FOUND "YES" ) + SET( FONTCONFIG_LIBRARIES ${FONTCONFIG_LIBRARY} ) + FIND_PROGRAM(FONTCONFIG_CONFIG NAMES fontconfig-config PATHS ${prefix}/bin ${exec_prefix}/bin /usr/local/bin /opt/local/bin /usr/bin /usr/nekoware/bin /usr/X11/bin) +# EXEC_PROGRAM(${FONTCONFIG_CONFIG} ARGS --libs OUTPUT_VARIABLE FONTCONFIG_LIBS) +# EXEC_PROGRAM(${FONTCONFIG_CONFIG} ARGS --cflags OUTPUT_VARIABLE FONTCONFIG_CFLAGS) +# MESSAGE(STATUS ${FONTCONFIG_LIBS}) +# MESSAGE(STATUS ${FONTCONFIG_CFLAGS}) + ENDIF (FONTCONFIG_INCLUDE_DIR) +ENDIF (FONTCONFIG_LIBRARY) diff --git a/slim/cmake/modules/FindCkConnector.cmake b/slim/cmake/modules/FindCkConnector.cmake new file mode 100644 index 0000000..5130ca0 --- /dev/null +++ b/slim/cmake/modules/FindCkConnector.cmake @@ -0,0 +1,59 @@ +# - Try to find the ConsoleKit connector library (libck-connector) +# Once done this will define +# +# CKCONNECTOR_FOUND - system has the CK Connector +# CKCONNECTOR_INCLUDE_DIR - the CK Connector include directory +# CKCONNECTOR_LIBRARIES - the libraries needed to use CK Connector + +# Copyright (c) 2008, Kevin Kofler, +# modeled after FindLibArt.cmake: +# Copyright (c) 2006, Alexander Neundorf, +# +# Redistribution and use is allowed according to the terms of the BSD license. +# For details see the accompanying COPYING-CMAKE-SCRIPTS file. + + +if (CKCONNECTOR_INCLUDE_DIR AND CKCONNECTOR_LIBRARIES) + + # in cache already + SET(CKCONNECTOR_FOUND TRUE) + +else (CKCONNECTOR_INCLUDE_DIR AND CKCONNECTOR_LIBRARIES) + + IF (NOT WIN32) + FIND_PACKAGE(PkgConfig) + IF (PKG_CONFIG_FOUND) + # use pkg-config to get the directories and then use these values + # in the FIND_PATH() and FIND_LIBRARY() calls + pkg_check_modules(_CKCONNECTOR_PC QUIET ck-connector) + ENDIF (PKG_CONFIG_FOUND) + ENDIF (NOT WIN32) + + FIND_PATH(CKCONNECTOR_INCLUDE_DIR ck-connector.h + ${_CKCONNECTOR_PC_INCLUDE_DIRS} + ) + + FIND_LIBRARY(CKCONNECTOR_LIBRARIES NAMES ck-connector + PATHS + ${_CKCONNECTOR_PC_LIBDIR} + ) + + + if (CKCONNECTOR_INCLUDE_DIR AND CKCONNECTOR_LIBRARIES) + set(CKCONNECTOR_FOUND TRUE) + endif (CKCONNECTOR_INCLUDE_DIR AND CKCONNECTOR_LIBRARIES) + + + if (CKCONNECTOR_FOUND) + if (NOT CkConnector_FIND_QUIETLY) + message(STATUS "Found ck-connector: ${CKCONNECTOR_LIBRARIES}") + endif (NOT CkConnector_FIND_QUIETLY) + else (CKCONNECTOR_FOUND) + if (CkConnector_FIND_REQUIRED) + message(FATAL_ERROR "Could NOT find ck-connector") + endif (CkConnector_FIND_REQUIRED) + endif (CKCONNECTOR_FOUND) + + MARK_AS_ADVANCED(CKCONNECTOR_INCLUDE_DIR CKCONNECTOR_LIBRARIES) + +endif (CKCONNECTOR_INCLUDE_DIR AND CKCONNECTOR_LIBRARIES) diff --git a/slim/cmake/modules/FindDBus.cmake b/slim/cmake/modules/FindDBus.cmake new file mode 100644 index 0000000..f227cc2 --- /dev/null +++ b/slim/cmake/modules/FindDBus.cmake @@ -0,0 +1,72 @@ +# - Try to find the low-level D-Bus library +# Once done this will define +# +# DBUS_FOUND - system has D-Bus +# DBUS_INCLUDE_DIR - the D-Bus include directory +# DBUS_ARCH_INCLUDE_DIR - the D-Bus architecture-specific include directory +# DBUS_LIBRARIES - the libraries needed to use D-Bus + +# Copyright (c) 2008, Kevin Kofler, +# modeled after FindLibArt.cmake: +# Copyright (c) 2006, Alexander Neundorf, +# +# Redistribution and use is allowed according to the terms of the BSD license. +# For details see the accompanying COPYING-CMAKE-SCRIPTS file. + +if (DBUS_INCLUDE_DIR AND DBUS_ARCH_INCLUDE_DIR AND DBUS_LIBRARIES) + + # in cache already + SET(DBUS_FOUND TRUE) + +else (DBUS_INCLUDE_DIR AND DBUS_ARCH_INCLUDE_DIR AND DBUS_LIBRARIES) + + IF (NOT WIN32) + FIND_PACKAGE(PkgConfig) + IF (PKG_CONFIG_FOUND) + # use pkg-config to get the directories and then use these values + # in the FIND_PATH() and FIND_LIBRARY() calls + pkg_check_modules(_DBUS_PC QUIET dbus-1) + ENDIF (PKG_CONFIG_FOUND) + ENDIF (NOT WIN32) + + FIND_PATH(DBUS_INCLUDE_DIR dbus/dbus.h + ${_DBUS_PC_INCLUDE_DIRS} + /usr/include + /usr/include/dbus-1.0 + /usr/local/include + ) + + FIND_PATH(DBUS_ARCH_INCLUDE_DIR dbus/dbus-arch-deps.h + ${_DBUS_PC_INCLUDE_DIRS} + /usr/lib${LIB_SUFFIX}/include + /usr/lib${LIB_SUFFIX}/dbus-1.0/include + /usr/lib64/include + /usr/lib64/dbus-1.0/include + /usr/lib/include + /usr/lib/dbus-1.0/include + ) + + FIND_LIBRARY(DBUS_LIBRARIES NAMES dbus-1 dbus + PATHS + ${_DBUS_PC_LIBDIR} + ) + + + if (DBUS_INCLUDE_DIR AND DBUS_ARCH_INCLUDE_DIR AND DBUS_LIBRARIES) + set(DBUS_FOUND TRUE) + endif (DBUS_INCLUDE_DIR AND DBUS_ARCH_INCLUDE_DIR AND DBUS_LIBRARIES) + + + if (DBUS_FOUND) + if (NOT DBus_FIND_QUIETLY) + message(STATUS "Found D-Bus: ${DBUS_LIBRARIES}") + endif (NOT DBus_FIND_QUIETLY) + else (DBUS_FOUND) + if (DBus_FIND_REQUIRED) + message(FATAL_ERROR "Could NOT find D-Bus") + endif (DBus_FIND_REQUIRED) + endif (DBUS_FOUND) + + MARK_AS_ADVANCED(DBUS_INCLUDE_DIR DBUS_ARCH_INCLUDE_DIR DBUS_LIBRARIES) + +endif (DBUS_INCLUDE_DIR AND DBUS_ARCH_INCLUDE_DIR AND DBUS_LIBRARIES) diff --git a/slim/cmake/modules/FindPAM.cmake b/slim/cmake/modules/FindPAM.cmake new file mode 100644 index 0000000..f209c0b --- /dev/null +++ b/slim/cmake/modules/FindPAM.cmake @@ -0,0 +1,74 @@ +# - Try to find the PAM libraries +# Once done this will define +# +# PAM_FOUND - system has pam +# PAM_INCLUDE_DIR - the pam include directory +# PAM_LIBRARIES - libpam library + +if (PAM_INCLUDE_DIR AND PAM_LIBRARY) + # Already in cache, be silent + set(PAM_FIND_QUIETLY TRUE) +endif (PAM_INCLUDE_DIR AND PAM_LIBRARY) + +find_path(PAM_INCLUDE_DIR NAMES security/pam_appl.h pam/pam_appl.h) +find_library(PAM_LIBRARY pam) +find_library(DL_LIBRARY dl) + +if (PAM_INCLUDE_DIR AND PAM_LIBRARY) + set(PAM_FOUND TRUE) + if (DL_LIBRARY) + set(PAM_LIBRARIES ${PAM_LIBRARY} ${DL_LIBRARY}) + else (DL_LIBRARY) + set(PAM_LIBRARIES ${PAM_LIBRARY}) + endif (DL_LIBRARY) + + if (EXISTS ${PAM_INCLUDE_DIR}/pam/pam_appl.h) + # darwin claims to be something special + set(HAVE_PAM_PAM_APPL_H 1) + endif (EXISTS ${PAM_INCLUDE_DIR}/pam/pam_appl.h) + + if (NOT DEFINED PAM_MESSAGE_CONST) + include(CheckCXXSourceCompiles) + # XXX does this work with plain c? + check_cxx_source_compiles(" +#if ${HAVE_PAM_PAM_APPL_H}+0 +# include +#else +# include +#endif + +static int PAM_conv( + int num_msg, + const struct pam_message **msg, /* this is the culprit */ + struct pam_response **resp, + void *ctx) +{ + return 0; +} + +int main(void) +{ + struct pam_conv PAM_conversation = { + &PAM_conv, /* this bombs out if the above does not match */ + 0 + }; + + return 0; +} +" PAM_MESSAGE_CONST) + endif (NOT DEFINED PAM_MESSAGE_CONST) + set(PAM_MESSAGE_CONST ${PAM_MESSAGE_CONST} CACHE BOOL "PAM expects a conversation function with const pam_message") + +endif (PAM_INCLUDE_DIR AND PAM_LIBRARY) + +if (PAM_FOUND) + if (NOT PAM_FIND_QUIETLY) + message(STATUS "Found PAM: ${PAM_LIBRARIES}") + endif (NOT PAM_FIND_QUIETLY) +else (PAM_FOUND) + if (PAM_FIND_REQUIRED) + message(FATAL_ERROR "PAM was not found") + endif(PAM_FIND_REQUIRED) +endif (PAM_FOUND) + +mark_as_advanced(PAM_INCLUDE_DIR PAM_LIBRARY DL_LIBRARY PAM_MESSAGE_CONST) \ No newline at end of file diff --git a/slim/const.h b/slim/const.h new file mode 100644 index 0000000..e1bc5af --- /dev/null +++ b/slim/const.h @@ -0,0 +1,40 @@ +/* SLiM - Simple Login Manager + * Copyright (C) 1997, 1998 Per Liden + * Copyright (C) 2004-06 Simone Rota + * Copyright (C) 2004-06 Johannes Winkelmann + * Copyright (C) 2022-23 Rob Pearce + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + */ + +#ifndef _CONST_H_ +#define _CONST_H_ + +#define DISPLAY ":0.0" + +#define CONSOLE_STR "console" +#define HALT_STR "halt" +#define REBOOT_STR "reboot" +#define EXIT_STR "exit" +#define SUSPEND_STR "suspend" + +#define HIDE 0 +#define SHOW 1 + +#define OK_EXIT 0 +#define ERR_EXIT 1 + +/* variables replaced in login_cmd */ +#define SESSION_VAR "%session" +#define THEME_VAR "%theme" + +/* variables replaced in pre-session_cmd and post-session_cmd */ +#define USER_VAR "%user" + +/* max height/width for images */ +#define MAX_DIMENSION 10000 + +#endif /* _CONST_H_ */ diff --git a/slim/image.cpp b/slim/image.cpp new file mode 100644 index 0000000..4db4756 --- /dev/null +++ b/slim/image.cpp @@ -0,0 +1,958 @@ +/* SLiM - Simple Login Manager + * Copyright (C) 2004-06 Simone Rota + * Copyright (C) 2004-06 Johannes Winkelmann + * Copyright (C) 2012 Nobuhiro Iwamatsu + * Copyright (C) 2022-23 Rob Pearce + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * The following code has been adapted and extended from + * xplanet 1.0.1, Copyright (C) 2002-04 Hari Nair + */ + +#include +#include +#include +#include +#include +#include + +using namespace std; + +#include "log.h" +#include "const.h" +#include "image.h" + +extern "C" { + #include + #include +} + +Image::Image() + : width(0), height(0), area(0), rgb_data(NULL), png_alpha(NULL) +{ +} + +Image::Image ( const int w, const int h, const unsigned char *rgb, + const unsigned char *alpha) + : width(w), height(h), area(w*h) +{ + width = w; + height = h; + area = w * h; + + rgb_data = (unsigned char *) malloc(3 * area); + memcpy(rgb_data, rgb, 3 * area); + + if (alpha == NULL) { + png_alpha = NULL; + } else { + png_alpha = (unsigned char *) malloc(area); + memcpy(png_alpha, alpha, area); + } +} + +Image::~Image() +{ + free(rgb_data); + free(png_alpha); +} + +bool Image::Read(const char *filename) +{ + char buf[4]; + unsigned char *ubuf = (unsigned char *) buf; + int success; + int nr; + + FILE *file; + file = fopen(filename, "rb"); + if (file == NULL) + return(false); + + /* see what kind of file we have */ + + nr = fread(buf, 1, 4, file); + fclose(file); + if ( nr < 4 ) + return false; // Failed to read 4 bytes; probably empty file + + if ((ubuf[0] == 0x89) && !strncmp("PNG", buf+1, 3)) + success = readPng(filename, &width, &height, &rgb_data, &png_alpha); + else if ((ubuf[0] == 0xff) && (ubuf[1] == 0xd8)) + success = readJpeg(filename, &width, &height, &rgb_data); + else + { + fprintf(stderr, "Unknown image format\n"); + success = 0; + } + return(success == 1); +} + +void Image::Reduce(const int factor) +{ + if (factor < 1) + return; + + int scale = 1; + for (int i = 0; i < factor; i++) + scale *= 2; + + double scale2 = scale*scale; + + int w = width / scale; + int h = height / scale; + int new_area = w * h; + + unsigned char *new_rgb = (unsigned char *) malloc(3 * new_area); + memset(new_rgb, 0, 3 * new_area); + + unsigned char *new_alpha = NULL; + if (png_alpha != NULL) { + new_alpha = (unsigned char *) malloc(new_area); + memset(new_alpha, 0, new_area); + } + + int ipos = 0; + for (int j = 0; j < height; j++) { + int js = j / scale; + for (int i = 0; i < width; i++) { + int is = i/scale; + for (int k = 0; k < 3; k++) + new_rgb[3*(js * w + is) + k] += static_cast ((rgb_data[3*ipos + k] + 0.5) / scale2); + + if (png_alpha != NULL) + new_alpha[js * w + is] += static_cast (png_alpha[ipos]/scale2); + ipos++; + } + } + + free(rgb_data); + free(png_alpha); + + rgb_data = new_rgb; + png_alpha = new_alpha; + width = w; + height = h; + + area = w * h; +} + +void Image::Resize(const int w, const int h) +{ + + if (width==w && height==h){ + return; + } + + int new_area = w * h; + + unsigned char *new_rgb = (unsigned char *) malloc(3 * new_area); + unsigned char *new_alpha = NULL; + if (png_alpha != NULL) + new_alpha = (unsigned char *) malloc(new_area); + + const double scale_x = ((double) w) / width; + const double scale_y = ((double) h) / height; + + int ipos = 0; + for (int j = 0; j < h; j++) { + const double y = j / scale_y; + for (int i = 0; i < w; i++) { + const double x = i / scale_x; + if (new_alpha == NULL) + getPixel(x, y, new_rgb + 3*ipos); + else + getPixel(x, y, new_rgb + 3*ipos, new_alpha + ipos); + ipos++; + } + } + + free(rgb_data); + free(png_alpha); + + rgb_data = new_rgb; + png_alpha = new_alpha; + width = w; + height = h; + + area = w * h; +} + +/* Find the color of the desired point using bilinear interpolation. */ +/* Assume the array indices refer to the center of the pixel, so each */ +/* pixel has corners at (i - 0.5, j - 0.5) and (i + 0.5, j + 0.5) */ +void Image::getPixel(double x, double y, unsigned char *pixel) +{ + getPixel(x, y, pixel, NULL); +} + +void Image::getPixel(double x, double y, unsigned char *pixel, unsigned char *alpha) +{ + if (x < -0.5) + x = -0.5; + if (x >= width - 0.5) + x = width - 0.5; + + if (y < -0.5) + y = -0.5; + if (y >= height - 0.5) + y = height - 0.5; + + int ix0 = (int) (floor(x)); + int ix1 = ix0 + 1; + if (ix0 < 0) + ix0 = width - 1; + if (ix1 >= width) + ix1 = 0; + + int iy0 = (int) (floor(y)); + int iy1 = iy0 + 1; + if (iy0 < 0) + iy0 = 0; + if (iy1 >= height) + iy1 = height - 1; + + const double t = x - floor(x); + const double u = 1 - (y - floor(y)); + + double weight[4]; + weight[1] = t * u; + weight[0] = u - weight[1]; + weight[2] = 1 - t - u + weight[1]; + weight[3] = t - weight[1]; + + unsigned char *pixels[4]; + pixels[0] = rgb_data + 3 * (iy0 * width + ix0); + pixels[1] = rgb_data + 3 * (iy0 * width + ix1); + pixels[2] = rgb_data + 3 * (iy1 * width + ix0); + pixels[3] = rgb_data + 3 * (iy1 * width + ix1); + + memset(pixel, 0, 3); + for (int i = 0; i < 4; i++) { + for (int j = 0; j < 3; j++) + pixel[j] += (unsigned char) (weight[i] * pixels[i][j]); + } + + if (alpha != NULL) { + unsigned char pixels[4]; + pixels[0] = png_alpha[iy0 * width + ix0]; + pixels[1] = png_alpha[iy0 * width + ix1]; + pixels[2] = png_alpha[iy0 * width + ix0]; + pixels[3] = png_alpha[iy1 * width + ix1]; + + for (int i = 0; i < 4; i++) + *alpha = (unsigned char) (weight[i] * pixels[i]); + } +} + + +/** + * Merge the image with a background, taking care of the image Alpha + * transparency. (background alpha is ignored). + * + * The image is merged with the section of background at position (x, y). + * The background must fully contain the image. + * If the image does not have any transparency (no alpha data) then this + * is a no-operation. + * @note use of double to calculate the new value of a U8 + */ +void Image::Merge ( const Image* background, const int x, const int y ) +{ + if ( ( x + width > background->Width() ) + || ( y + height > background->Height() ) ) + return; + + if (png_alpha != NULL) + { + unsigned char *new_rgb = (unsigned char *) malloc(3 * width * height); + const unsigned char *bg_rgb = background->getRGBData(); + double tmp; + int opos = 0; + for (int j = 0; j < height; j++) + { + int ipos = (y+j) * background->Width() + x; + for (int i = 0; i < width; i++) + { + for (int k = 0; k < 3; k++) + { + tmp = rgb_data[3*opos + k]*png_alpha[opos]/255.0 + + bg_rgb[3*ipos + k]*(1-png_alpha[opos]/255.0); + new_rgb[3*opos + k] = static_cast (tmp); + } + opos++; + ipos++; + } + } + free(rgb_data); + free(png_alpha); + rgb_data = new_rgb; + png_alpha = NULL; + } +} + + +/* Merge the image with a background, taking care of the + * image Alpha transparency. (background alpha is ignored). + * The images is merged on position (x, y) on the + * background, the background must contain the image. + */ +#define IMG_POS_RGB(p, x) (3 * p + x) +void Image::Merge_non_crop(Image* background, const int x, const int y) +{ + int bg_w = background->Width(); + int bg_h = background->Height(); + + if (x + width > bg_w || y + height > bg_h) + return; + + double tmp; + unsigned char *new_rgb = (unsigned char *)malloc(3 * bg_w * bg_h); + const unsigned char *bg_rgb = background->getRGBData(); + int pnl_pos = 0; + int bg_pos = 0; + int pnl_w_end = x + width; + int pnl_h_end = y + height; + + memcpy(new_rgb, bg_rgb, 3 * bg_w * bg_h); + + for (int j = 0; j < bg_h; j++) { + for (int i = 0; i < bg_w; i++) { + if (j >= y && i >= x && j < pnl_h_end && i < pnl_w_end ) { + for (int k = 0; k < 3; k++) { + if (png_alpha != NULL) + tmp = rgb_data[IMG_POS_RGB(pnl_pos, k)] + * png_alpha[pnl_pos]/255.0 + + bg_rgb[IMG_POS_RGB(bg_pos, k)] + * (1 - png_alpha[pnl_pos]/255.0); + else + tmp = rgb_data[IMG_POS_RGB(pnl_pos, k)]; + + new_rgb[IMG_POS_RGB(bg_pos, k)] = static_cast(tmp); + } + pnl_pos++; + } + bg_pos++; + } + } + + width = bg_w; + height = bg_h; + + free(rgb_data); + free(png_alpha); + rgb_data = new_rgb; + png_alpha = NULL; +} + + +/* Tile the image growing its size to the minimum entire + * multiple of w * h. + * The new dimensions should be > of the current ones. + * Note that this flattens image (alpha removed) + */ +void Image::Tile(const int w, const int h) +{ + if (w < width || h < height) + return; + + int nx = w / width; + if (w % width > 0) + nx++; + int ny = h / height; + if (h % height > 0) + ny++; + + int newwidth = nx*width; + int newheight=ny*height; + + unsigned char *new_rgb = (unsigned char *) malloc(3 * newwidth * newheight); + memset(new_rgb, 0, 3 * width * height * nx * ny); + + int ipos = 0; + int opos = 0; + + for (int r = 0; r < ny; r++) { + for (int c = 0; c < nx; c++) { + for (int j = 0; j < height; j++) { + for (int i = 0; i < width; i++) { + opos = j*width + i; + ipos = r*width*height*nx + j*newwidth + c*width +i; + for (int k = 0; k < 3; k++) { + new_rgb[3*ipos + k] = static_cast (rgb_data[3*opos + k]); + } + } + } + } + } + + free(rgb_data); + free(png_alpha); + rgb_data = new_rgb; + png_alpha = NULL; + width = newwidth; + height = newheight; + area = width * height; + Crop(0,0,w,h); +} + + +/* Crop the image + */ +void Image::Crop(const int x, const int y, const int w, const int h) +{ + if (x+w > width || y+h > height) { + return; + } + + int x2 = x + w; + int y2 = y + h; + unsigned char *new_rgb = (unsigned char *) malloc(3 * w * h); + memset(new_rgb, 0, 3 * w * h); + unsigned char *new_alpha = NULL; + if (png_alpha != NULL) { + new_alpha = (unsigned char *) malloc(w * h); + memset(new_alpha, 0, w * h); + } + + int ipos = 0; + int opos = 0; + + for (int j = 0; j < height; j++) { + for (int i = 0; i < width; i++) { + if (j>=y && i>=x && j (rgb_data[3*opos + k]); + } + if (png_alpha != NULL) + new_alpha[ipos] = static_cast (png_alpha[opos]); + ipos++; + } + opos++; + } + } + + free(rgb_data); + free(png_alpha); + rgb_data = new_rgb; + if (png_alpha != NULL) + png_alpha = new_alpha; + width = w; + height = h; + area = w * h; +} + + +/* Center the image in a rectangle of given width and height. + * Fills the remaining space (if any) with the hex color + */ +void Image::Center(const int w, const int h, const char *hex) +{ + unsigned long packed_rgb; + sscanf(hex, "%lx", &packed_rgb); + + unsigned long r = packed_rgb>>16; + unsigned long g = packed_rgb>>8 & 0xff; + unsigned long b = packed_rgb & 0xff; + + unsigned char *new_rgb = (unsigned char *) malloc(3 * w * h); + memset(new_rgb, 0, 3 * w * h); + + int x = (w - width) / 2; + int y = (h - height) / 2; + + if (x<0) { + Crop((width - w)/2,0,w,height); + x = 0; + } + if (y<0) { + Crop(0,(height - h)/2,width,h); + y = 0; + } + int x2 = x + width; + int y2 = y + height; + + int ipos = 0; + int opos = 0; + double tmp; + + area = w * h; + for (int i = 0; i < area; i++) { + new_rgb[3*i] = r; + new_rgb[3*i+1] = g; + new_rgb[3*i+2] = b; + } + + if (png_alpha != NULL) { + for (int j = 0; j < h; j++) { + for (int i = 0; i < w; i++) { + if (j>=y && i>=x && j (tmp); + } + opos++; + } + } + } + } else { + for (int j = 0; j < h; j++) { + for (int i = 0; i < w; i++) { + if (j>=y && i>=x && j (tmp); + } + opos++; + } + } + } + } + + free(rgb_data); + free(png_alpha); + rgb_data = new_rgb; + png_alpha = NULL; + width = w; + height = h; +} + + +/* Fill the image with the given color and adjust its dimensions + * to passed values. + */ +void Image::Plain(const int w, const int h, const char *hex) +{ + unsigned long packed_rgb; + sscanf(hex, "%lx", &packed_rgb); + + unsigned long r = packed_rgb>>16; + unsigned long g = packed_rgb>>8 & 0xff; + unsigned long b = packed_rgb & 0xff; + + unsigned char *new_rgb = (unsigned char *) malloc(3 * w * h); + memset(new_rgb, 0, 3 * w * h); + + area = w * h; + for (int i = 0; i < area; i++) { + new_rgb[3*i] = r; + new_rgb[3*i+1] = g; + new_rgb[3*i+2] = b; + } + + free(rgb_data); + free(png_alpha); + rgb_data = new_rgb; + png_alpha = NULL; + width = w; + height = h; +} + + +void Image::computeShift(unsigned long mask, + unsigned char &left_shift, + unsigned char &right_shift) +{ + left_shift = 0; + right_shift = 8; + if (mask != 0) { + while ((mask & 0x01) == 0) { + left_shift++; + mask >>= 1; + } + while ((mask & 0x01) == 1) { + right_shift--; + mask >>= 1; + } + } +} + + +Pixmap Image::createPixmap(Display* dpy, int scr, Window win) +{ + int i, j; /* loop variables */ + + const int depth = DefaultDepth(dpy, scr); + Visual *visual = DefaultVisual(dpy, scr); + Colormap colormap = DefaultColormap(dpy, scr); + + Pixmap tmp = XCreatePixmap(dpy, win, width, height, depth); + + char *pixmap_data = NULL; + switch (depth) { + case 32: + case 24: + pixmap_data = new char[4 * width * height]; + break; + case 16: + case 15: + pixmap_data = new char[2 * width * height]; + break; + case 8: + pixmap_data = new char[width * height]; + break; + default: + break; + } + + XImage *ximage = XCreateImage(dpy, visual, depth, ZPixmap, 0, + pixmap_data, width, height, + 8, 0); + + int entries; + XVisualInfo v_template; + v_template.visualid = XVisualIDFromVisual(visual); + XVisualInfo *visual_info = XGetVisualInfo(dpy, VisualIDMask, + &v_template, &entries); + + unsigned long ipos = 0; + switch (visual_info->c_class) { + case PseudoColor: { + XColor xc; + xc.flags = DoRed | DoGreen | DoBlue; + + int num_colors = 256; + XColor *colors = new XColor[num_colors]; + for (i = 0; i < num_colors; i++) + colors[i].pixel = (unsigned long) i; + XQueryColors(dpy, colormap, colors, num_colors); + + int *closest_color = new int[num_colors]; + + for (i = 0; i < num_colors; i++) { + xc.red = (i & 0xe0) << 8; /* highest 3 bits */ + xc.green = (i & 0x1c) << 11; /* middle 3 bits */ + xc.blue = (i & 0x03) << 14; /* lowest 2 bits */ + + /* find the closest color in the colormap */ + double distance, distance_squared, min_distance = 0; + for (int ii = 0; ii < num_colors; ii++) { + distance = colors[ii].red - xc.red; + distance_squared = distance * distance; + distance = colors[ii].green - xc.green; + distance_squared += distance * distance; + distance = colors[ii].blue - xc.blue; + distance_squared += distance * distance; + + if ((ii == 0) || (distance_squared <= min_distance)) { + min_distance = distance_squared; + closest_color[i] = ii; + } + } + } + + for (j = 0; j < height; j++) { + for (i = 0; i < width; i++) { + xc.red = (unsigned short) (rgb_data[ipos++] & 0xe0); + xc.green = (unsigned short) (rgb_data[ipos++] & 0xe0); + xc.blue = (unsigned short) (rgb_data[ipos++] & 0xc0); + + xc.pixel = xc.red | (xc.green >> 3) | (xc.blue >> 6); + XPutPixel(ximage, i, j, + colors[closest_color[xc.pixel]].pixel); + } + } + delete [] colors; + delete [] closest_color; + } + break; + case TrueColor: { + unsigned char red_left_shift; + unsigned char red_right_shift; + unsigned char green_left_shift; + unsigned char green_right_shift; + unsigned char blue_left_shift; + unsigned char blue_right_shift; + + computeShift(visual_info->red_mask, red_left_shift, + red_right_shift); + computeShift(visual_info->green_mask, green_left_shift, + green_right_shift); + computeShift(visual_info->blue_mask, blue_left_shift, + blue_right_shift); + + unsigned long pixel; + unsigned long red, green, blue; + for (j = 0; j < height; j++) { + for (i = 0; i < width; i++) { + red = (unsigned long) + rgb_data[ipos++] >> red_right_shift; + green = (unsigned long) + rgb_data[ipos++] >> green_right_shift; + blue = (unsigned long) + rgb_data[ipos++] >> blue_right_shift; + + pixel = (((red << red_left_shift) & visual_info->red_mask) + | ((green << green_left_shift) + & visual_info->green_mask) + | ((blue << blue_left_shift) + & visual_info->blue_mask)); + + XPutPixel(ximage, i, j, pixel); + } + } + } + break; + default: { + logStream << APPNAME << ": could not load image" << endl; + return(tmp); + } + } + + GC gc = XCreateGC(dpy, win, 0, NULL); + XPutImage(dpy, tmp, gc, ximage, 0, 0, 0, 0, width, height); + + XFreeGC(dpy, gc); + + XFree(visual_info); + + delete [] pixmap_data; + + /* Set ximage data to NULL since pixmap data was deallocated above */ + ximage->data = NULL; + XDestroyImage(ximage); + + return(tmp); +} + +int Image::readJpeg(const char *filename, int *width, int *height, + unsigned char **rgb) +{ + int ret = 0; + struct jpeg_decompress_struct cinfo; + struct jpeg_error_mgr jerr; + unsigned char *ptr = NULL; + + FILE *infile = fopen(filename, "rb"); + if (infile == NULL) { + logStream << APPNAME << "Cannot fopen file: " << filename << endl; + return ret; + } + + cinfo.err = jpeg_std_error(&jerr); + jpeg_create_decompress(&cinfo); + jpeg_stdio_src(&cinfo, infile); + jpeg_read_header(&cinfo, TRUE); + jpeg_start_decompress(&cinfo); + + /* Prevent against integer overflow */ + if ( cinfo.output_width >= MAX_DIMENSION + || cinfo.output_height >= MAX_DIMENSION) + { + logStream << APPNAME << "Unreasonable dimension found in file: " + << filename << endl; + goto close_file; + } + + *width = cinfo.output_width; + *height = cinfo.output_height; + + rgb[0] = (unsigned char*) + malloc(3 * cinfo.output_width * cinfo.output_height); + if (rgb[0] == NULL) { + logStream << APPNAME << ": Can't allocate memory for JPEG file." + << endl; + goto close_file; + } + + if (cinfo.output_components == 3) { + ptr = rgb[0]; + while (cinfo.output_scanline < cinfo.output_height) { + jpeg_read_scanlines(&cinfo, &ptr, 1); + ptr += 3 * cinfo.output_width; + } + } else if (cinfo.output_components == 1) { + ptr = (unsigned char*) malloc(cinfo.output_width); + if (ptr == NULL) { + logStream << APPNAME << ": Can't allocate memory for JPEG file." + << endl; + goto rgb_free; + } + + unsigned int ipos = 0; + while (cinfo.output_scanline < cinfo.output_height) { + jpeg_read_scanlines(&cinfo, &ptr, 1); + + for (unsigned int i = 0; i < cinfo.output_width; i++) { + memset(rgb[0] + ipos, ptr[i], 3); + ipos += 3; + } + } + + free(ptr); + } + + jpeg_finish_decompress(&cinfo); + + ret = 1; + goto close_file; + +rgb_free: + free(rgb[0]); + +close_file: + jpeg_destroy_decompress(&cinfo); + fclose(infile); + + return(ret); +} + +int Image::readPng(const char *filename, int *width, int *height, + unsigned char **rgb, unsigned char **alpha) +{ + int ret = 0; + + png_structp png_ptr; + png_infop info_ptr; + png_bytepp row_pointers; + + unsigned char *ptr = NULL; + png_uint_32 w, h; + int bit_depth, color_type, interlace_type; + int i; + + FILE *infile = fopen(filename, "rb"); + if (infile == NULL) { + logStream << APPNAME << "Can not fopen file: " << filename << endl; + return ret; + } + + png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, + (png_voidp) NULL, + (png_error_ptr) NULL, + (png_error_ptr) NULL); + if (!png_ptr) { + goto file_close; + } + + info_ptr = png_create_info_struct(png_ptr); + if (!info_ptr) { + png_destroy_read_struct(&png_ptr, (png_infopp) NULL, + (png_infopp) NULL); + } + +#if PNG_LIBPNG_VER_MAJOR >= 1 && PNG_LIBPNG_VER_MINOR >= 4 + if (setjmp(png_jmpbuf((png_ptr)))) + goto png_destroy; +#else + if (setjmp(png_ptr->jmpbuf)) + goto png_destroy; +#endif + + + png_init_io(png_ptr, infile); + png_read_info(png_ptr, info_ptr); + + png_get_IHDR(png_ptr, info_ptr, &w, &h, &bit_depth, &color_type, + &interlace_type, (int *) NULL, (int *) NULL); + + /* Prevent against integer overflow */ + if(w >= MAX_DIMENSION || h >= MAX_DIMENSION) { + logStream << APPNAME << "Unreasonable dimension found in file: " + << filename << endl; + goto png_destroy; + } + + *width = (int) w; + *height = (int) h; + + if (color_type == PNG_COLOR_TYPE_RGB_ALPHA + || color_type == PNG_COLOR_TYPE_GRAY_ALPHA) + { + alpha[0] = (unsigned char *) malloc(*width * *height); + if (alpha[0] == NULL) { + logStream << APPNAME + << ": Can't allocate memory for alpha channel in PNG file." + << endl; + goto png_destroy; + } + } + + /* Change a paletted/grayscale image to RGB */ + if (color_type == PNG_COLOR_TYPE_PALETTE && bit_depth <= 8) + { + png_set_expand(png_ptr); + } + + /* Change a grayscale image to RGB */ + if (color_type == PNG_COLOR_TYPE_GRAY + || color_type == PNG_COLOR_TYPE_GRAY_ALPHA) + { + png_set_gray_to_rgb(png_ptr); + } + + /* If the PNG file has 16 bits per channel, strip them down to 8 */ + if (bit_depth == 16) { + png_set_strip_16(png_ptr); + } + + /* use 1 byte per pixel */ + png_set_packing(png_ptr); + + row_pointers = (png_byte **) malloc(*height * sizeof(png_bytep)); + if (row_pointers == NULL) { + logStream << APPNAME << ": Can't allocate memory for PNG file." << endl; + goto png_destroy; + } + + for (i = 0; i < *height; i++) { + row_pointers[i] = (png_byte*) malloc(4 * *width); + if (row_pointers == NULL) { + logStream << APPNAME << ": Can't allocate memory for PNG file." + << endl; + goto rows_free; + } + } + + png_read_image(png_ptr, row_pointers); + + rgb[0] = (unsigned char *) malloc(3 * (*width) * (*height)); + if (rgb[0] == NULL) { + logStream << APPNAME << ": Can't allocate memory for PNG file." << endl; + goto rows_free; + } + + if (alpha[0] == NULL) { + ptr = rgb[0]; + for (i = 0; i < *height; i++) { + memcpy(ptr, row_pointers[i], 3 * (*width)); + ptr += 3 * (*width); + } + } else { + ptr = rgb[0]; + for (i = 0; i < *height; i++) { + unsigned int ipos = 0; + for (int j = 0; j < *width; j++) { + *ptr++ = row_pointers[i][ipos++]; + *ptr++ = row_pointers[i][ipos++]; + *ptr++ = row_pointers[i][ipos++]; + alpha[0][i * (*width) + j] = row_pointers[i][ipos++]; + } + } + } + + ret = 1; /* data reading is OK */ + +rows_free: + for (i = 0; i < *height; i++) { + if (row_pointers[i] != NULL ) { + free(row_pointers[i]); + } + } + + free(row_pointers); + +png_destroy: + png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp) NULL); + +file_close: + fclose(infile); + return(ret); +} + diff --git a/slim/image.h b/slim/image.h new file mode 100644 index 0000000..0d414a3 --- /dev/null +++ b/slim/image.h @@ -0,0 +1,75 @@ +/* SLiM - Simple Login Manager + Copyright (C) 2004-06 Simone Rota + Copyright (C) 2004-06 Johannes Winkelmann + Copyright (C) 2012 Nobuhiro Iwamatsu + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + The following code has been adapted and extended from + xplanet 1.0.1, Copyright (C) 2002-04 Hari Nair +*/ + +#ifndef _IMAGE_H_ +#define _IMAGE_H_ + +#include +#include + +class Image +{ +public: + Image(); + Image(const int w, const int h, const unsigned char *rgb, + const unsigned char *alpha); + + ~Image(); + + const unsigned char *getPNGAlpha() const { + return(png_alpha); + } + const unsigned char *getRGBData() const { + return(rgb_data); + } + + void getPixel(double px, double py, unsigned char *pixel); + void getPixel(double px, double py, unsigned char *pixel, + unsigned char *alpha); + + int Width() const { + return(width); + } + int Height() const { + return(height); + } + + bool Read(const char *filename); + + void Reduce(const int factor); + void Resize(const int w, const int h); + void Merge ( const Image *background, const int x, const int y ); + void Merge_non_crop(Image* background, const int x, const int y); + void Crop(const int x, const int y, const int w, const int h); + void Tile(const int w, const int h); + void Center(const int w, const int h, const char *hex); + void Plain(const int w, const int h, const char *hex); + + void computeShift(unsigned long mask, unsigned char &left_shift, + unsigned char &right_shift); + + Pixmap createPixmap(Display *dpy, int scr, Window win); + +private: + int width, height, area; + unsigned char *rgb_data; + unsigned char *png_alpha; + + int readJpeg(const char *filename, int *width, int *height, + unsigned char **rgb); + int readPng(const char *filename, int *width, int *height, + unsigned char **rgb, unsigned char **alpha); +}; + +#endif /* _IMAGE_H_ */ diff --git a/slim/jpeg.c b/slim/jpeg.c new file mode 100644 index 0000000..f239220 --- /dev/null +++ b/slim/jpeg.c @@ -0,0 +1,101 @@ +/**************************************************************************** + jpeg.c - read and write jpeg images using libjpeg routines + Copyright (C) 2002 Hari Nair + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +****************************************************************************/ + +#include +#include +#include + +#include +#include "const.h" + +int read_jpeg(const char *filename, int *width, int *height, unsigned char **rgb) +{ + int ret = 0; + struct jpeg_decompress_struct cinfo; + struct jpeg_error_mgr jerr; + unsigned char *ptr = NULL; + unsigned int i, ipos; + + FILE *infile = fopen(filename, "rb"); + if (infile == NULL) { + fprintf(stderr, "Can not fopen file: %s\n",filename); + return ret; + } + + cinfo.err = jpeg_std_error(&jerr); + jpeg_create_decompress(&cinfo); + jpeg_stdio_src(&cinfo, infile); + jpeg_read_header(&cinfo, TRUE); + jpeg_start_decompress(&cinfo); + + /* Prevent against integer overflow */ + if(cinfo.output_width >= MAX_DIMENSION || cinfo.output_height >= MAX_DIMENSION) { + fprintf(stderr, "Unreasonable dimension found in file: %s\n",filename); + goto close_file; + } + + *width = cinfo.output_width; + *height = cinfo.output_height; + + rgb[0] = malloc(3 * cinfo.output_width * cinfo.output_height); + if (rgb[0] == NULL) { + fprintf(stderr, "Can't allocate memory for JPEG file.\n"); + goto close_file; + } + + if (cinfo.output_components == 3) { + ptr = rgb[0]; + while (cinfo.output_scanline < cinfo.output_height) { + jpeg_read_scanlines(&cinfo, &ptr, 1); + ptr += 3 * cinfo.output_width; + } + } else if (cinfo.output_components == 1) { + ptr = malloc(cinfo.output_width); + if (ptr == NULL) { + fprintf(stderr, "Can't allocate memory for JPEG file.\n"); + goto rgb_free; + } + + ipos = 0; + while (cinfo.output_scanline < cinfo.output_height) { + jpeg_read_scanlines(&cinfo, &ptr, 1); + + for (i = 0; i < cinfo.output_width; i++) { + memset(rgb[0] + ipos, ptr[i], 3); + ipos += 3; + } + } + + free(ptr); + } + + jpeg_finish_decompress(&cinfo); + + ret = 1; + goto close_file; + +rgb_free: + free(rgb[0]); + +close_file: + jpeg_destroy_decompress(&cinfo); + fclose(infile); + + return(ret); +} diff --git a/slim/log.cpp b/slim/log.cpp new file mode 100644 index 0000000..d9fd5d8 --- /dev/null +++ b/slim/log.cpp @@ -0,0 +1,57 @@ +/* SLiM - Simple Login Manager + * Copyright (C) 1997, 1998 Per Liden + * Copyright (C) 2004-06 Simone Rota + * Copyright (C) 2004-06 Johannes Winkelmann + * Copyright (C) 2022 Rob Pearce + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + */ + +#include "const.h" +#include "log.h" +#include +#include + +LogUnit::LogUnit() +{ + logOut = &cerr; +} + +bool LogUnit::openLog(const char * filename) +{ + if (logFile.is_open()) { + cerr << APPNAME + << ": opening a new Log file, while another is already open" + << endl; + logFile.close(); + } + + // cerr is the default + if ( ( strcmp(filename, "/dev/stderr") == 0 ) + || ( strcmp(filename, "stderr") == 0 ) ) + { + logOut = &cerr; + return true; + } + + logFile.open(filename, ios_base::out|ios_base::app); + if ( logFile ) + { + logOut = &logFile; + return true; + } + return false; +} + +void LogUnit::closeLog() +{ + if (logFile.is_open()) + logFile.close(); +} + + +/* Now instantiate a singleton for all the rest of the code to use */ +LogUnit logStream; diff --git a/slim/log.h b/slim/log.h new file mode 100644 index 0000000..1cfb905 --- /dev/null +++ b/slim/log.h @@ -0,0 +1,47 @@ +#ifndef _LOG_H_ +#define _LOG_H_ + +#ifdef USE_CONSOLEKIT +#include "Ck.h" +#endif +#ifdef USE_PAM +#include "PAM.h" +#endif +#include + +using namespace std; + +class LogUnit +{ + ofstream logFile; + ostream * logOut; +public: + bool openLog(const char * filename); + void closeLog(); + + LogUnit(); + + ~LogUnit() { closeLog(); } + + template LogUnit & operator<<(const Type & text) + { + *logOut << text; logOut->flush(); + return *this; + } + + LogUnit & operator<<(ostream & (*fp)(ostream&)) + { + *logOut << fp; logOut->flush(); + return *this; + } + + LogUnit & operator<<(ios_base & (*fp)(ios_base&)) + { + *logOut << fp; logOut->flush(); + return *this; + } +}; + +extern LogUnit logStream; + +#endif /* _LOG_H_ */ diff --git a/slim/main.cpp b/slim/main.cpp new file mode 100644 index 0000000..909aa0f --- /dev/null +++ b/slim/main.cpp @@ -0,0 +1,24 @@ +/* + * SLiM - Simple Login Manager + * Copyright (C) 1997, 1998 Per Liden + * Copyright (C) 2004-06 Simone Rota + * Copyright (C) 2004-06 Johannes Winkelmann + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. +*/ + +#include "app.h" +#include "const.h" + +App* LoginApp = 0; + +int main(int argc, char** argv) +{ + LoginApp = new App(argc, argv); + LoginApp->Run(); + return 0; +} + diff --git a/slim/numlock.cpp b/slim/numlock.cpp new file mode 100644 index 0000000..ed92885 --- /dev/null +++ b/slim/numlock.cpp @@ -0,0 +1,112 @@ +/* + * SLiM - Simple Login Manager + * Copyright (C) 2004-06 Simone Rota + * Copyright (C) 2004-06 Johannes Winkelmann + * Copyright (C) 2012 Nobuhiro Iwamatsu + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * Code adapted from NumLockX, look at the end of this file for + * the original Copyright information. +*/ + +#include "numlock.h" +#include + +NumLock::NumLock() +{ +} + +int NumLock::xkb_init(Display* dpy) +{ + int xkb_opcode, xkb_event, xkb_error; + int xkb_lmaj = XkbMajorVersion; + int xkb_lmin = XkbMinorVersion; + + return XkbLibraryVersion( &xkb_lmaj, &xkb_lmin ) + && XkbQueryExtension( dpy, &xkb_opcode, &xkb_event, &xkb_error, + &xkb_lmaj, &xkb_lmin ); +} + +unsigned int NumLock::xkb_mask_modifier( XkbDescPtr xkb, const char *name ) +{ + int i; + if( !xkb || !xkb->names ) + return 0; + + for( i = 0; i < XkbNumVirtualMods; i++ ) { + char* modStr = XGetAtomName( xkb->dpy, xkb->names->vmods[i] ); + if( modStr != NULL && strcmp(name, modStr) == 0 ) { + unsigned int mask; + XkbVirtualModsToReal( xkb, 1 << i, &mask ); + return mask; + } + } + return 0; +} + +unsigned int NumLock::xkb_numlock_mask(Display* dpy) +{ + XkbDescPtr xkb; + + xkb = XkbGetKeyboard( dpy, XkbAllComponentsMask, XkbUseCoreKbd ); + if( xkb != NULL ) { + unsigned int mask = xkb_mask_modifier( xkb, "NumLock" ); + XkbFreeKeyboard( xkb, 0, True ); + return mask; + } + return 0; +} + +void NumLock::control_numlock(Display *dpy, bool flag) +{ + unsigned int mask; + + if( !xkb_init(dpy) ) + return; + + mask = xkb_numlock_mask(dpy); + if( mask == 0 ) + return; + + if( flag == true ) + XkbLockModifiers ( dpy, XkbUseCoreKbd, mask, mask); + else + XkbLockModifiers ( dpy, XkbUseCoreKbd, mask, 0); +} + +void NumLock::setOn(Display *dpy) +{ + control_numlock(dpy, true); +} + +void NumLock::setOff(Display *dpy) +{ + control_numlock(dpy, false); +} + +/* + * Copyright (C) 2000-2001 Lubos Lunak + * Copyright (C) 2001 Oswald Buddenhagen + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. +*/ diff --git a/slim/numlock.h b/slim/numlock.h new file mode 100644 index 0000000..d7bb911 --- /dev/null +++ b/slim/numlock.h @@ -0,0 +1,33 @@ +/* SLiM - Simple Login Manager + Copyright (C) 2004-06 Simone Rota + Copyright (C) 2004-06 Johannes Winkelmann + Copyright (C) 2012 Nobuhiro Iwamatsu + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +*/ + +#ifndef _NUMLOCK_H_ +#define _NUMLOCK_H_ + +#include +#include +#include + +class NumLock +{ +public: + NumLock(); + static void setOn(Display *dpy); + static void setOff(Display *dpy); + +private: + static int xkb_init(Display *dpy); + static unsigned int xkb_mask_modifier(XkbDescPtr xkb, const char *name); + static unsigned int xkb_numlock_mask(Display *dpy); + static void control_numlock(Display *dpy, bool flag); +}; + +#endif /* _NUMLOCK_H_ */ diff --git a/slim/pam.sample b/slim/pam.sample new file mode 100755 index 0000000..78a981f --- /dev/null +++ b/slim/pam.sample @@ -0,0 +1,10 @@ +#%PAM-1.0 +auth requisite pam_nologin.so +auth required pam_env.so +auth required pam_unix.so +account required pam_unix.so +password required pam_unix.so +session required pam_limits.so +session required pam_unix.so +session optional pam_loginuid.so +session optional pam_ck_connector.so diff --git a/slim/panel.cpp b/slim/panel.cpp new file mode 100644 index 0000000..73f7aba --- /dev/null +++ b/slim/panel.cpp @@ -0,0 +1,1035 @@ +/* + * SLiM - Simple Login Manager + * Copyright (C) 1997, 1998 Per Liden + * Copyright (C) 2004-06 Simone Rota + * Copyright (C) 2004-06 Johannes Winkelmann + * Copyright (C) 2022-23 Rob Pearce + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + */ + +#include +#include +#include +#include +#include // for XA_PIXMAP +#include // for sleep +#include "const.h" +#include "image.h" +#include "log.h" +#include "cfg.h" +#include "switchuser.h" +#include "panel.h" + +using namespace std; + +Panel::Panel(Display* dpy, int scr, Window root, Cfg* config, + const string& themedir, PanelType panel_mode) + : cfg(config), mode(panel_mode), Dpy(dpy), Scr(scr), Root(root), + session_name(""), session_exec("") +{ + if (mode == Mode_Lock) + { + Win = root; + viewport = GetPrimaryViewport(); + } + else if ( mode == Mode_Test ) + { + XWindowAttributes attributes; + XGetWindowAttributes(Dpy, Root, &attributes); + viewport.x = 0; // Not actually used. The window's position + viewport.y = 0; // is irrelevant to our drawing functions + viewport.width = attributes.width; + viewport.height = attributes.height; + } + else + { + /* The existing behaviour in DM mode was to always use the full + * screen size */ + viewport.x = 0; + viewport.y = 0; + // AFAICT the following two lines, used in GetPrimaryViewport, do + // exactly the same as the ones that follow, which were used elsewhere + //viewport.width = DisplayWidth(Dpy, Scr); + //viewport.height = DisplayHeight(Dpy, Scr); + viewport.width = XWidthOfScreen(ScreenOfDisplay(Dpy, Scr)); + viewport.height = XHeightOfScreen(ScreenOfDisplay(Dpy, Scr)); + } + + /* Init GC */ + XGCValues gcv; + unsigned long gcm; + gcm = GCForeground|GCBackground|GCGraphicsExposures; + gcv.foreground = GetColor("black"); + gcv.background = GetColor("white"); + gcv.graphics_exposures = False; + + TextGC = XCreateGC(Dpy, Root, gcm, &gcv); + + if (mode == Mode_Lock) { + gcm = GCGraphicsExposures; + gcv.graphics_exposures = False; + WinGC = XCreateGC(Dpy, Win, gcm, &gcv); + if (WinGC == 0) { + cerr << APPNAME << ": failed to create pixmap\n."; + exit(ERR_EXIT); + } + } + + // Intern _XROOTPMAP_ID property - does this belong here? + BackgroundPixmapId = XInternAtom(Dpy, "_XROOTPMAP_ID", False); + + font = XftFontOpenName(Dpy, Scr, cfg->getOption("input_font").c_str()); + welcomefont = XftFontOpenName(Dpy, Scr, cfg->getOption("welcome_font").c_str()); + enterfont = XftFontOpenName(Dpy, Scr, cfg->getOption("username_font").c_str()); + msgfont = XftFontOpenName(Dpy, Scr, cfg->getOption("msg_font").c_str()); + + Visual* visual = DefaultVisual(Dpy, Scr); + Colormap colormap = DefaultColormap(Dpy, Scr); + /* NOTE: using XftColorAllocValue() would be a better solution. Lazy me. */ + XftColorAllocName(Dpy, visual, colormap, cfg->getOption("input_color").c_str(), &inputcolor); + XftColorAllocName(Dpy, visual, colormap, cfg->getOption("input_shadow_color").c_str(), &inputshadowcolor); + XftColorAllocName(Dpy, visual, colormap, cfg->getOption("welcome_color").c_str(), &welcomecolor); + XftColorAllocName(Dpy, visual, colormap, cfg->getOption("welcome_shadow_color").c_str(), &welcomeshadowcolor); + XftColorAllocName(Dpy, visual, colormap, cfg->getOption("username_color").c_str(), &entercolor); + XftColorAllocName(Dpy, visual, colormap, cfg->getOption("username_shadow_color").c_str(), &entershadowcolor); + XftColorAllocName(Dpy, visual, colormap, cfg->getOption("msg_color").c_str(), &msgcolor); + XftColorAllocName(Dpy, visual, colormap, cfg->getOption("msg_shadow_color").c_str(), &msgshadowcolor); + XftColorAllocName(Dpy, visual, colormap, + cfg->getOption("session_color").c_str(), &sessioncolor); + XftColorAllocName(Dpy, visual, colormap, + cfg->getOption("session_shadow_color").c_str(), &sessionshadowcolor); + + /* Load properties from config / theme */ + input_name_x = cfg->getIntOption("input_name_x"); + input_name_y = cfg->getIntOption("input_name_y"); + input_pass_x = cfg->getIntOption("input_pass_x"); + input_pass_y = cfg->getIntOption("input_pass_y"); + inputShadowXOffset = cfg->getIntOption("input_shadow_xoffset"); + inputShadowYOffset = cfg->getIntOption("input_shadow_yoffset"); + + if (input_pass_x < 0 || input_pass_y < 0){ /* single inputbox mode */ + input_pass_x = input_name_x; + input_pass_y = input_name_y; + } + + /* Load panel and background image */ + string panelpng = ""; + panelpng = panelpng + themedir +"/panel.png"; + image = new Image; + bool loaded = image->Read(panelpng.c_str()); + if (!loaded) { /* try jpeg if png failed */ + panelpng = themedir + "/panel.jpg"; + loaded = image->Read(panelpng.c_str()); + if (!loaded) { + logStream << APPNAME + << ": could not load panel image for theme '" + << basename((char*)themedir.c_str()) << "'" + << endl; + exit(ERR_EXIT); + } + } + + bgImg = new Image(); + string bgstyle = cfg->getOption("background_style"); + if (bgstyle != "color") { + panelpng = themedir +"/background.png"; + loaded = bgImg->Read(panelpng.c_str()); + if (!loaded) { /* try jpeg if png failed */ + panelpng = themedir + "/background.jpg"; + loaded = bgImg->Read(panelpng.c_str()); + if (!loaded){ + logStream << APPNAME + << ": could not load background image for theme '" + << basename((char*)themedir.c_str()) << "'" + << endl; + exit(ERR_EXIT); + } + } + } + + if (bgstyle == "stretch") + bgImg->Resize(viewport.width, viewport.height); + else if (bgstyle == "tile") + bgImg->Tile(viewport.width, viewport.height); + else if (bgstyle == "center") { + string hexvalue = cfg->getOption("background_color"); + hexvalue = hexvalue.substr(1,6); + bgImg->Center(viewport.width, + viewport.height, + hexvalue.c_str()); + } else { // plain color or error + string hexvalue = cfg->getOption("background_color"); + hexvalue = hexvalue.substr(1,6); + bgImg->Center(viewport.width, + viewport.height, + hexvalue.c_str()); + } + + string cfgX = cfg->getOption("input_panel_x"); + string cfgY = cfg->getOption("input_panel_y"); + + X = Cfg::absolutepos(cfgX, viewport.width, image->Width()); + Y = Cfg::absolutepos(cfgY, viewport.height, image->Height()); + + if (mode == Mode_Lock) { + // In slimlock, the window we draw on is always the root, not the + // XSimpleWindow created by OpenPanel to represent the panel area. + // Thus we apply a hack to offset the input positions. It's a shame + // we don't do the job properly, as this hack isn't applied to any + // of the static text + input_name_x += X; + input_name_y += Y; + input_pass_x += X; + input_pass_y += Y; + } + + if (mode == Mode_Lock) { + /* Merge image into background without crop, so that PanelPixmap is + * the whole screen (background image with panel drawn on it) */ + image->Merge_non_crop(bgImg, X, Y); + } else { + /* Merge image with cropped background, so that PanelPixmap is the + * panel with the relevant part of the X root image included instead + * of the alpha channel */ + image->Merge(bgImg, X, Y); + } + PanelPixmap = image->createPixmap(Dpy, Scr, Root); + + /* Read (and substitute vars in) the welcome message */ + welcome_message = cfg->getWelcomeMessage(); + + if (mode == Mode_Lock) { + SetName(getenv("USER")); + field = Get_Passwd; + OnExpose(); + } + MsgExtents.width = 0; +} + +Panel::~Panel() +{ + Visual* visual = DefaultVisual(Dpy, Scr); + Colormap colormap = DefaultColormap(Dpy, Scr); + + XftColorFree(Dpy, visual, colormap, &inputcolor); + XftColorFree(Dpy, visual, colormap, &inputshadowcolor); + XftColorFree(Dpy, visual, colormap, &welcomecolor); + XftColorFree(Dpy, visual, colormap, &welcomeshadowcolor); + XftColorFree(Dpy, visual, colormap, &entercolor); + XftColorFree(Dpy, visual, colormap, &entershadowcolor); + XftColorFree(Dpy, visual, colormap, &msgcolor); + XftColorFree(Dpy, visual, colormap, &msgshadowcolor); + XftColorFree(Dpy, visual, colormap, &sessioncolor); + XftColorFree(Dpy, visual, colormap, &sessionshadowcolor); + + XFreeGC(Dpy, TextGC); + XftFontClose(Dpy, font); + XftFontClose(Dpy, msgfont); + XftFontClose(Dpy, welcomefont); + XftFontClose(Dpy, enterfont); + + if (mode == Mode_Lock) + XFreeGC(Dpy, WinGC); + + delete bgImg; + delete image; +} + + +/** + * Set the (previously loaded and adjusted) background image as the window + * background for the root window. + */ +void Panel::setBackground(void) +{ + Pixmap p = bgImg->createPixmap(Dpy, Scr, Root); + XSetWindowBackgroundPixmap(Dpy, Root, p); + XChangeProperty(Dpy, Root, BackgroundPixmapId, XA_PIXMAP, 32, + PropModeReplace, (unsigned char *)&p, 1); + + XClearWindow(Dpy, Root); + + XFlush(Dpy); +} + + +/* Hide the cursor */ +void Panel::HideCursor() +{ + if (cfg->getOption("hidecursor") == "true") + { + XColor black; + char cursordata[1]; + Pixmap cursorpixmap; + Cursor cursor; + cursordata[0]=0; + cursorpixmap = XCreateBitmapFromData(Dpy, Root, cursordata, 1, 1); + black.red=0; + black.green=0; + black.blue=0; + cursor = XCreatePixmapCursor(Dpy, cursorpixmap, cursorpixmap, &black, &black, 0, 0); + //XFreePixmap(dpy, cursorpixmap); // man page is confusing as to whether this is right + XDefineCursor(Dpy, Root, cursor); + } +} + + +/* Open the login panel. Not used by slimlock */ +void Panel::OpenPanel() +{ + /* Create window */ + Win = XCreateSimpleWindow(Dpy, Root, X, Y, + image->Width(), + image->Height(), + 0, GetColor("white"), GetColor("white")); + + /* Events */ + XSelectInput(Dpy, Win, ExposureMask | KeyPressMask); + + /* Set background */ + XSetWindowBackgroundPixmap(Dpy, Win, PanelPixmap); + + /* Show window */ + XMapWindow(Dpy, Win); + XMoveWindow(Dpy, Win, X, Y); /* override wm positioning (for tests) */ + + /* Grab keyboard */ + XGrabKeyboard(Dpy, Win, False, GrabModeAsync, GrabModeAsync, CurrentTime); + + XFlush(Dpy); +} + +void Panel::ClosePanel() +{ + XUngrabKeyboard(Dpy, CurrentTime); + XUnmapWindow(Dpy, Win); + XDestroyWindow(Dpy, Win); + XFlush(Dpy); +} + +void Panel::WrongPassword(int timeout) +{ + string message; + + if ( mode != Mode_Lock ) + { + XClearWindow(Dpy, Root); + } + +#if 0 + if (CapsLockOn) + message = cfg->getOption("passwd_feedback_capslock"); + else +#endif + message = cfg->getOption("passwd_feedback_msg"); + + XftDraw *draw = XftDrawCreate ( Dpy, Root, + DefaultVisual(Dpy, Scr), DefaultColormap(Dpy, Scr) ); + XftTextExtents8(Dpy, msgfont, reinterpret_cast(message.c_str()), + message.length(), &MsgExtents); + + string cfgX = cfg->getOption("passwd_feedback_x"); + string cfgY = cfg->getOption("passwd_feedback_y"); + int shadowXOffset = cfg->getIntOption("msg_shadow_xoffset"); + int shadowYOffset = cfg->getIntOption("msg_shadow_yoffset"); + int msg_x = Cfg::absolutepos(cfgX, viewport.width, MsgExtents.width); + int msg_y = Cfg::absolutepos(cfgY, viewport.height, MsgExtents.height); + + MsgExtents.x = msg_x; + MsgExtents.y = msg_y - MsgExtents.height; + + if ( timeout > 0 ) + { + OnExpose(); + if ( msg_x >= 0 && msg_y >= 0 ) + SlimDrawString8(draw, &msgcolor, msgfont, msg_x, msg_y, message, + &msgshadowcolor, shadowXOffset, shadowYOffset); + + if (cfg->getOption("bell") == "1") + XBell(Dpy, 100); + XFlush(Dpy); + sleep(timeout); + } + ResetPasswd(); + if ( mode != Mode_Lock ) + { + if ( cfg->getIntOption("keep_user_on_fail") == 0 ) + { + ResetName(); + } + field = Get_Name; + } + OnExpose(); + // The message should stay on the screen even after the password field is + // cleared, methinks. I don't like this solution, but it works. + if ( msg_x >= 0 && msg_y >= 0 ) + SlimDrawString8(draw, &msgcolor, msgfont, msg_x, msg_y, message, + &msgshadowcolor, shadowXOffset, shadowYOffset); + XSync(Dpy, True); + XftDrawDestroy(draw); +} + +void Panel::Message(const string& text) +{ + string cfgX, cfgY; + XGlyphInfo extents; + XftDraw *draw; + + // The message positions are screen-relative, not panel-relative + draw = XftDrawCreate(Dpy, Root, + DefaultVisual(Dpy, Scr), DefaultColormap(Dpy, Scr)); + + XftTextExtents8(Dpy, msgfont, + reinterpret_cast(text.c_str()), + text.length(), &extents); + cfgX = cfg->getOption("msg_x"); + cfgY = cfg->getOption("msg_y"); + int shadowXOffset = cfg->getIntOption("msg_shadow_xoffset"); + int shadowYOffset = cfg->getIntOption("msg_shadow_yoffset"); + int msg_x, msg_y; + + msg_x = Cfg::absolutepos(cfgX, viewport.width, extents.width); + msg_y = Cfg::absolutepos(cfgY, viewport.height, extents.height); + + SlimDrawString8 (draw, &msgcolor, msgfont, msg_x, msg_y, + text, + &msgshadowcolor, + shadowXOffset, shadowYOffset); + XFlush(Dpy); + XftDrawDestroy(draw); +} + +unsigned long Panel::GetColor(const char* colorname) +{ + XColor color; + XWindowAttributes attributes; + + XGetWindowAttributes(Dpy, Root, &attributes); + + color.pixel = 0; + + if(!XParseColor(Dpy, attributes.colormap, colorname, &color)) + logStream << APPNAME << ": can't parse color " << colorname << endl; + else if(!XAllocColor(Dpy, attributes.colormap, &color)) + logStream << APPNAME << ": can't allocate color " << colorname << endl; + + return color.pixel; +} + +void Panel::TextCursor(int visible) +{ + const char* text = NULL; + int xx = 0, yy = 0, y2 = 0, cheight = 0; + const char* txth = "Wj"; /* used to get cursor height */ + + // The constructor and other conditionals guarantee that + // if (mode == Mode_Lock) field = Get_Passwd; + + switch(field) { + case Get_Passwd: + text = HiddenPasswdBuffer.c_str(); + xx = input_pass_x; + yy = input_pass_y; + break; + + case Get_Name: + text = NameBuffer.c_str(); + xx = input_name_x; + yy = input_name_y; + break; + } + + XGlyphInfo extents; + XftTextExtents8(Dpy, font, (XftChar8*)txth, strlen(txth), &extents); + cheight = extents.height; + y2 = yy - extents.y + extents.height; + XftTextExtents8(Dpy, font, (XftChar8*)text, strlen(text), &extents); + xx += extents.width; + + if(visible == SHOW) { + if (mode == Mode_Lock) { + xx += viewport.x; + yy += viewport.y; + y2 += viewport.y; + } + XSetForeground(Dpy, TextGC, + GetColor(cfg->getOption("input_color").c_str())); + + XDrawLine(Dpy, Win, TextGC, + xx+1, yy-cheight, + xx+1, y2); + } else { + if (mode == Mode_Lock) + ApplyBackground(Rectangle(xx+1, yy-cheight, + 1, y2-(yy-cheight)+1)); + else + XClearArea(Dpy, Win, xx+1, yy-cheight, + 1, y2-(yy-cheight)+1, false); + } +} + +void Panel::EventHandler(const Panel::FieldType& curfield) +{ + XEvent event; + field = curfield; + bool loop = true; + + if ( (mode != Mode_Lock) && ( MsgExtents.width == 0 ) ) + OnExpose(); + + struct pollfd x11_pfd = {0}; + x11_pfd.fd = ConnectionNumber(Dpy); + x11_pfd.events = POLLIN; + + while (loop) + { + if (XPending(Dpy) || poll(&x11_pfd, 1, -1) > 0) + { + while(XPending(Dpy)) + { + XNextEvent(Dpy, &event); + switch(event.type) + { + case Expose: + OnExpose(); + break; + + case KeyPress: + loop=OnKeyPress(event); + break; + } + } + if ( MsgExtents.width > 0 ) + { + if (mode == Mode_Lock) + ApplyBackground(Rectangle(MsgExtents.x, + MsgExtents.y, MsgExtents.width+1, + MsgExtents.height+2)); + else + XClearArea(Dpy, Root, MsgExtents.x, MsgExtents.y, + MsgExtents.width+1, MsgExtents.height+2, false); + MsgExtents.width = 0; + } + } + } + + return; +} + +void Panel::OnExpose(void) +{ + XftDraw *draw = XftDrawCreate(Dpy, Win, + DefaultVisual(Dpy, Scr), DefaultColormap(Dpy, Scr)); + + if (mode == Mode_Lock) + ApplyBackground(); + else + XClearWindow(Dpy, Win); + + if (input_pass_x != input_name_x || input_pass_y != input_name_y){ + SlimDrawString8 (draw, &inputcolor, font, input_name_x, input_name_y, + NameBuffer, + &inputshadowcolor, + inputShadowXOffset, inputShadowYOffset); + SlimDrawString8 (draw, &inputcolor, font, input_pass_x, input_pass_y, + HiddenPasswdBuffer, + &inputshadowcolor, + inputShadowXOffset, inputShadowYOffset); + } else { /*single input mode */ + switch(field) { + case Get_Passwd: + SlimDrawString8 (draw, &inputcolor, font, + input_pass_x, input_pass_y, + HiddenPasswdBuffer, + &inputshadowcolor, + inputShadowXOffset, inputShadowYOffset); + break; + case Get_Name: + SlimDrawString8 (draw, &inputcolor, font, + input_name_x, input_name_y, + NameBuffer, + &inputshadowcolor, + inputShadowXOffset, inputShadowYOffset); + break; + } + } + + XftDrawDestroy (draw); + TextCursor(SHOW); + ShowText(); +} + +void Panel::EraseLastChar(std::string &formerString) +{ + switch(field) { + case Get_Name: + if (! NameBuffer.empty()) { + formerString=NameBuffer; + NameBuffer.erase(--NameBuffer.end()); + } + break; + + case Get_Passwd: + if (!PasswdBuffer.empty()) { + formerString=HiddenPasswdBuffer; + PasswdBuffer.erase(--PasswdBuffer.end()); + HiddenPasswdBuffer.erase(--HiddenPasswdBuffer.end()); + } + break; + } +} + +bool Panel::OnKeyPress(XEvent& event) +{ + char ascii; + KeySym keysym; + XComposeStatus compstatus; + int xx = 0; + int yy = 0; + string text; + string formerString = ""; + + XLookupString(&event.xkey, &ascii, 1, &keysym, &compstatus); + switch(keysym){ + case XK_F1: + if ( mode != Mode_Lock ) // Can't change session in a screen lock + SwitchSession(); + return true; + + case XK_F11: + /* Take a screenshot */ + if ( system(cfg->getOption("screenshot_cmd").c_str()) < 0 ) + logStream << APPNAME << ": screenshot_cmd failed" << endl; + return true; + + case XK_Return: + case XK_KP_Enter: + if (field==Get_Name) + { + /* Don't allow an empty username */ + if (NameBuffer.empty()) + return true; + + if (NameBuffer==CONSOLE_STR) + action = Console; + else if (NameBuffer==HALT_STR) + action = Halt; + else if (NameBuffer==REBOOT_STR) + action = Reboot; + else if (NameBuffer==SUSPEND_STR) + action = Suspend; + else if (NameBuffer==EXIT_STR) + action = Exit; + else + action = Login; + } + return false; + + default: + break; + } + + TextCursor(HIDE); + switch(keysym){ + case XK_Delete: + case XK_BackSpace: + EraseLastChar(formerString); + break; + + case XK_w: + case XK_u: + if (reinterpret_cast(event).state & ControlMask) + { + switch(field) { + case Get_Passwd: + formerString = HiddenPasswdBuffer; + HiddenPasswdBuffer.clear(); + PasswdBuffer.clear(); + break; + case Get_Name: + formerString = NameBuffer; + NameBuffer.clear(); + break; + } + break; + } + /* Deliberate fall-through */ + case XK_h: + if (reinterpret_cast(event).state & ControlMask) + { + EraseLastChar(formerString); + break; + } + /* Deliberate fall-through */ + default: + if (isprint(ascii) && (keysym < XK_Shift_L || keysym > XK_Hyper_R)) + { + switch(field) { + case Get_Name: + formerString=NameBuffer; + if (NameBuffer.length() < INPUT_MAXLENGTH_NAME-1) + { + NameBuffer.append(&ascii,1); + } + break; + case Get_Passwd: + formerString=HiddenPasswdBuffer; + if (PasswdBuffer.length() < INPUT_MAXLENGTH_PASSWD-1) + { + PasswdBuffer.append(&ascii,1); + HiddenPasswdBuffer.append("*"); + } + break; + } + } + else + { // *RP* I think this is to fix the fake bolding if the user presses TAB + return true; //nodraw if notchange + } + break; + } + + XGlyphInfo extents; + XftDraw *draw = XftDrawCreate(Dpy, Win, + DefaultVisual(Dpy, Scr), DefaultColormap(Dpy, Scr)); + + switch(field) { + case Get_Name: + text = NameBuffer; + xx = input_name_x; + yy = input_name_y; + break; + + case Get_Passwd: + text = HiddenPasswdBuffer; + xx = input_pass_x; + yy = input_pass_y; + break; + } + + if (!formerString.empty()) + { + const char* txth = "Wj"; /* get proper maximum height ? */ + XftTextExtents8(Dpy, font, + reinterpret_cast(txth), strlen(txth), &extents); + int maxHeight = extents.height; + + XftTextExtents8(Dpy, font, + reinterpret_cast(formerString.c_str()), + formerString.length(), &extents); + int maxLength = extents.width; + + if (mode == Mode_Lock) + ApplyBackground(Rectangle(input_pass_x - 3, + input_pass_y - maxHeight - 3, + maxLength + 6, maxHeight + 6)); + else + XClearArea(Dpy, Win, xx - 3, yy-maxHeight - 3, + maxLength + 6, maxHeight + 6, false); + } + + if (!text.empty()) + { + SlimDrawString8 (draw, &inputcolor, font, xx, yy, + text, + &inputshadowcolor, + inputShadowXOffset, inputShadowYOffset); + } + + XftDrawDestroy (draw); + TextCursor(SHOW); + return true; +} + + +/* Draw welcome and "enter username" messages */ +void Panel::ShowText() +{ + string cfgX, cfgY; + XGlyphInfo extents; + + bool singleInputMode = ( input_name_x == input_pass_x + && input_name_y == input_pass_y ); + + /// @bug this draw context is assumed relative to the panel but in lock + /// mode it's actually relative to the background + XftDraw *draw = XftDrawCreate(Dpy, Win, + DefaultVisual(Dpy, Scr), DefaultColormap(Dpy, Scr)); + /* welcome message */ + XftTextExtents8(Dpy, welcomefont, (XftChar8*)welcome_message.c_str(), + strlen(welcome_message.c_str()), &extents); + cfgX = cfg->getOption("welcome_x"); + cfgY = cfg->getOption("welcome_y"); + int shadowXOffset = cfg->getIntOption("welcome_shadow_xoffset"); + int shadowYOffset = cfg->getIntOption("welcome_shadow_yoffset"); + + welcome_x = Cfg::absolutepos(cfgX, image->Width(), extents.width); + welcome_y = Cfg::absolutepos(cfgY, image->Height(), extents.height); + if (welcome_x >= 0 && welcome_y >= 0) { + SlimDrawString8 (draw, &welcomecolor, welcomefont, + welcome_x, welcome_y, + welcome_message, + &welcomeshadowcolor, shadowXOffset, shadowYOffset); + } + + /* Enter username-password message */ + string msg; + if (!singleInputMode|| field == Get_Passwd) { + msg = cfg->getOption("password_msg"); + XftTextExtents8(Dpy, enterfont, (XftChar8*)msg.c_str(), + strlen(msg.c_str()), &extents); + cfgX = cfg->getOption("password_x"); + cfgY = cfg->getOption("password_y"); + int shadowXOffset = cfg->getIntOption("username_shadow_xoffset"); + int shadowYOffset = cfg->getIntOption("username_shadow_yoffset"); + password_x = Cfg::absolutepos(cfgX, image->Width(), extents.width); + password_y = Cfg::absolutepos(cfgY, image->Height(), extents.height); + if (password_x >= 0 && password_y >= 0){ + SlimDrawString8 (draw, &entercolor, enterfont, password_x, password_y, + msg, &entershadowcolor, shadowXOffset, shadowYOffset); + } + } + + if ((!singleInputMode|| field == Get_Name) && mode != Mode_Lock ) { + msg = cfg->getOption("username_msg"); + XftTextExtents8(Dpy, enterfont, (XftChar8*)msg.c_str(), + strlen(msg.c_str()), &extents); + cfgX = cfg->getOption("username_x"); + cfgY = cfg->getOption("username_y"); + int shadowXOffset = cfg->getIntOption("username_shadow_xoffset"); + int shadowYOffset = cfg->getIntOption("username_shadow_yoffset"); + username_x = Cfg::absolutepos(cfgX, image->Width(), extents.width); + username_y = Cfg::absolutepos(cfgY, image->Height(), extents.height); + if (username_x >= 0 && username_y >= 0){ + SlimDrawString8 (draw, &entercolor, enterfont, username_x, username_y, + msg, &entershadowcolor, shadowXOffset, shadowYOffset); + } + } + XftDrawDestroy(draw); + + if (mode == Mode_Lock) { + // If only the password box is visible, draw the user name somewhere too + string user_msg = "User: " + GetName(); + int show_username = cfg->getIntOption("show_username"); + if (singleInputMode && show_username) { + Message(user_msg); + } + } +} + + +string Panel::getSession() +{ + return session_exec; +} + + +/* choose next available session type. Not used in lock mode */ +void Panel::SwitchSession() +{ + pair ses = cfg->nextSession(); + session_name = ses.first; + session_exec = ses.second; + if (session_name.size() > 0) { + ShowSession(); + } + } + + +/* Display session type on the screen. Not used in lock mode */ +void Panel::ShowSession() +{ + string msg_x, msg_y; + XClearWindow(Dpy, Root); + string currsession = cfg->getOption("session_msg") + " " + session_name; + XGlyphInfo extents; + + sessionfont = XftFontOpenName(Dpy, Scr, cfg->getOption("session_font").c_str()); + + XftDraw *draw = XftDrawCreate(Dpy, Root, + DefaultVisual(Dpy, Scr), DefaultColormap(Dpy, Scr)); + XftTextExtents8(Dpy, sessionfont, reinterpret_cast(currsession.c_str()), + currsession.length(), &extents); + msg_x = cfg->getOption("session_x"); + msg_y = cfg->getOption("session_y"); + int x = Cfg::absolutepos(msg_x, viewport.width, extents.width); + int y = Cfg::absolutepos(msg_y, viewport.height, extents.height); + int shadowXOffset = cfg->getIntOption("session_shadow_xoffset"); + int shadowYOffset = cfg->getIntOption("session_shadow_yoffset"); + + SlimDrawString8(draw, &sessioncolor, sessionfont, x, y, + currsession, + &sessionshadowcolor, + shadowXOffset, shadowYOffset); + XFlush(Dpy); + XftDrawDestroy(draw); +} + + +void Panel::SlimDrawString8(XftDraw *d, XftColor *color, XftFont *font, + int x, int y, const string& str, + XftColor* shadowColor, + int xOffset, int yOffset) +{ + if (mode == Mode_Lock) { + x += viewport.x; + y += viewport.y; + } + + if (xOffset && yOffset) { + XftDrawStringUtf8(d, shadowColor, font, x+xOffset, y+yOffset, + reinterpret_cast(str.c_str()), str.length()); + } + + XftDrawStringUtf8(d, color, font, x, y, + reinterpret_cast(str.c_str()), str.length()); +} + +Panel::ActionType Panel::getAction(void) const +{ + return action; +} + +void Panel::Reset(void) +{ + ResetName(); + ResetPasswd(); +} + +void Panel::ResetName(void) +{ + NameBuffer.clear(); +} + +void Panel::ResetPasswd(void) +{ + PasswdBuffer.clear(); + HiddenPasswdBuffer.clear(); +} + + +/* Pre-load the user name input box with the provided string. + * Used to set the default user, if so configured, and by slimlock to set the + * currently logged-in user. + */ +void Panel::SetName(const string& name) +{ + NameBuffer=name; + action = Login; +} + +const string& Panel::GetName(void) const +{ + return NameBuffer; +} + +const string& Panel::GetPasswd(void) const +{ + return PasswdBuffer; +} + + +/** + * Identify the viewport (physical screen?) to draw on. This allows slimlock + * to handle Xinerama-type multi-monitor setups. Not currently used by slim + */ +Rectangle Panel::GetPrimaryViewport() +{ + Rectangle fallback; + Rectangle result; + + RROutput primary; + XRROutputInfo *primary_info; + XRRScreenResources *resources; + XRRCrtcInfo *crtc_info; + + int crtc; + + fallback.x = 0; + fallback.y = 0; + fallback.width = DisplayWidth(Dpy, Scr); + fallback.height = DisplayHeight(Dpy, Scr); + + resources = XRRGetScreenResources(Dpy, Win); + if (!resources) + { + cerr << "XRRGetScreenResources failed\n"; + return fallback; + } + + primary = XRRGetOutputPrimary(Dpy, Win); + if (!primary) { + // No "primary" defined (by the WM, usually) but could still have + // multiple monitors or setups, so default to the first output. + primary = resources->outputs[0]; + } + + primary_info = XRRGetOutputInfo(Dpy, resources, primary); + if (!primary_info) { + cerr << "XRRGetOutputInfo failed\n"; + XRRFreeScreenResources(resources); + return fallback; + } + + // Fixes bug with multiple monitors. Just pick first monitor if + // XRRGetOutputInfo gives returns bad value for crtc. + if (primary_info->crtc < 1) { + if (primary_info->ncrtc > 0) { + crtc = primary_info->crtcs[0]; + } else { + cerr << "Cannot get crtc from xrandr.\n"; + exit(EXIT_FAILURE); + } + } else { + crtc = primary_info->crtc; + } + + crtc_info = XRRGetCrtcInfo(Dpy, resources, crtc); + + if (!crtc_info) { + cerr << "XRRGetCrtcInfo failed\n"; + XRRFreeOutputInfo(primary_info); + XRRFreeScreenResources(resources); + return fallback; + } + + result.x = crtc_info->x; + result.y = crtc_info->y; + result.width = crtc_info->width; + result.height = crtc_info->height; + + XRRFreeCrtcInfo(crtc_info); + XRRFreeOutputInfo(primary_info); + XRRFreeScreenResources(resources); + + return result; +} + + +/** + * Re-draw the background over a rectangle. This method is only used in "lock" + * mode - the DM mode uses XClearArea instead. + */ +void Panel::ApplyBackground(Rectangle rect) +{ + int ret = 0; + + if (rect.is_empty()) { + rect.x = 0; + rect.y = 0; + rect.width = viewport.width; + rect.height = viewport.height; + } + + ret = XCopyArea(Dpy, PanelPixmap, Win, WinGC, + rect.x, rect.y, rect.width, rect.height, + viewport.x + rect.x, viewport.y + rect.y); + + if (!ret) + cerr << APPNAME << ": failed to put pixmap on the screen\n."; +} + diff --git a/slim/panel.h b/slim/panel.h new file mode 100644 index 0000000..8a7afbf --- /dev/null +++ b/slim/panel.h @@ -0,0 +1,188 @@ +/* SLiM - Simple Login Manager + Copyright (C) 1997, 1998 Per Liden + Copyright (C) 2004-06 Simone Rota + Copyright (C) 2004-06 Johannes Winkelmann + Copyright (C) 2013 Nobuhiro Iwamatsu + Copyright (C) 2022-23 Rob Pearce + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +*/ + +#ifndef _PANEL_H_ +#define _PANEL_H_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef NEEDS_BASENAME +#include +#endif + + +// Forward declarations +class Image; +class Cfg; + + +struct Rectangle { + int x; + int y; + unsigned int width; + unsigned int height; + + Rectangle() : x(0), y(0), width(0), height(0) {}; + Rectangle(int x, int y, unsigned int width, unsigned int height) + : x(x), y(y), width(width), height(height) + {} + + bool is_empty() const { return width == 0 || height == 0; } +}; + +class Panel +{ +public: + enum ActionType { + Login, + UnLock = Login, // slimlock doesn't actually care about this + Console, + Reboot, + Halt, + Exit, + Suspend + }; + + enum FieldType { + Get_Name, + Get_Passwd + }; + + enum PanelType { + Mode_DM, + Mode_Test, + Mode_Lock + }; + + Panel(Display *dpy, int scr, Window root, Cfg *config, + const std::string& themed, PanelType panel_mode); + ~Panel(); + void OpenPanel(); + void ClosePanel(); + void WrongPassword(int timeout); + void Message(const std::string &text); + void EventHandler(const FieldType &curfield); + std::string getSession(); + ActionType getAction(void) const; + + void Reset(void); + void ResetName(void); + void ResetPasswd(void); + void SetName(const std::string &name); + const std::string& GetName(void) const; + const std::string& GetPasswd(void) const; + void SwitchSession(); + + Atom BackgroundPixmapId; // from XInternAtom -- does it need to be a member var? + void setBackground(void); + void HideCursor(); + +private: + Panel(); + void TextCursor(int visible); + unsigned long GetColor(const char *colorname); + void OnExpose(void); + void EraseLastChar(std::string &formerString); + bool OnKeyPress(XEvent& event); + void ShowText(); + void ShowSession(); + + void SlimDrawString8(XftDraw *d, XftColor *color, XftFont *font, + int x, int y, const std::string &str, + XftColor *shadowColor, + int xOffset, int yOffset); + + Rectangle GetPrimaryViewport(); + void ApplyBackground(Rectangle = Rectangle()); + + /* Private data */ + PanelType mode; /* work mode */ + Cfg *cfg; + Display *Dpy; + int Scr; + Window Win; + Window Root; + int X, Y; + GC TextGC; + GC WinGC; + XftFont *font; + XftColor inputshadowcolor; + XftColor inputcolor; + XftColor msgcolor; + XftColor msgshadowcolor; + XftFont *msgfont; + XftFont *welcomefont; + XftColor welcomecolor; + XftFont *sessionfont; + XftColor sessioncolor; + XftColor sessionshadowcolor; + XftColor welcomeshadowcolor; + XftFont *enterfont; + XftColor entercolor; + XftColor entershadowcolor; + ActionType action; + FieldType field; + XGlyphInfo MsgExtents; + + /* Username/Password */ + std::string NameBuffer; + std::string PasswdBuffer; + std::string HiddenPasswdBuffer; + + /* screen stuff */ + Rectangle viewport; + + /* Configuration */ + int input_name_x; + int input_name_y; + int input_pass_x; + int input_pass_y; + int inputShadowXOffset; + int inputShadowYOffset; + int welcome_x; + int welcome_y; + int welcome_shadow_xoffset; + int welcome_shadow_yoffset; + int session_shadow_xoffset; + int session_shadow_yoffset; + int username_x; + int username_y; + int username_shadow_xoffset; + int username_shadow_yoffset; + int password_x; + int password_y; + std::string welcome_message; + + /* Pixmap data */ + Pixmap PanelPixmap; + + Image *image; + Image *bgImg; + + std::string themedir; + + /* Session handling */ + std::string session_name; + std::string session_exec; +}; + +#endif /* _PANEL_H_ */ diff --git a/slim/png.c b/slim/png.c new file mode 100644 index 0000000..601e435 --- /dev/null +++ b/slim/png.c @@ -0,0 +1,173 @@ +/**************************************************************************** + png.c - read and write png images using libpng routines. + Distributed with Xplanet. + Copyright (C) 2002 Hari Nair + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +****************************************************************************/ + +#include +#include + +#include +#include +#include +#include +#include "const.h" + +int read_png(const char *filename, int *width, int *height, unsigned char **rgb, + unsigned char **alpha) +{ + int ret = 0; + + png_structp png_ptr; + png_infop info_ptr; + png_bytepp row_pointers; + + unsigned char *ptr = NULL; + png_uint_32 w, h; + int bit_depth, color_type, interlace_type; + int i; + + FILE *infile = fopen(filename, "rb"); + if (infile == NULL) { + fprintf(stderr, "Can not fopen file: %s\n", filename); + return ret; + } + + png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, + (png_voidp)NULL, + (png_error_ptr)NULL, + (png_error_ptr)NULL); + if (!png_ptr) + goto file_close; + + info_ptr = png_create_info_struct(png_ptr); + if (!info_ptr) { + png_destroy_read_struct(&png_ptr, + (png_infopp)NULL, + (png_infopp)NULL); + } + +#if PNG_LIBPNG_VER_MAJOR >= 1 && PNG_LIBPNG_VER_MINOR >= 4 + if (setjmp(png_jmpbuf((png_ptr)))) +#else + if (setjmp(png_ptr->jmpbuf)) +#endif + goto png_destroy; + + png_init_io(png_ptr, infile); + png_read_info(png_ptr, info_ptr); + + png_get_IHDR(png_ptr, info_ptr, &w, &h, &bit_depth, &color_type, + &interlace_type, (int *) NULL, (int *) NULL); + + /* Prevent against integer overflow */ + if (w >= MAX_DIMENSION || h >= MAX_DIMENSION) { + fprintf(stderr, + "Unreasonable dimension found in file: %s\n", filename); + goto png_destroy; + } + + *width = (int) w; + *height = (int) h; + + if (color_type == PNG_COLOR_TYPE_RGB_ALPHA + || color_type == PNG_COLOR_TYPE_GRAY_ALPHA) { + alpha[0] = malloc(*width * *height); + if (alpha[0] == NULL) { + fprintf(stderr, + "Can't allocate memory for alpha channel in PNG file.\n"); + goto png_destroy; + } + } + + /* Change a paletted/grayscale image to RGB */ + if (color_type == PNG_COLOR_TYPE_PALETTE && bit_depth <= 8) + png_set_expand(png_ptr); + + /* Change a grayscale image to RGB */ + if (color_type == PNG_COLOR_TYPE_GRAY || + color_type == PNG_COLOR_TYPE_GRAY_ALPHA) + png_set_gray_to_rgb(png_ptr); + + /* If the PNG file has 16 bits per channel, strip them down to 8 */ + if (bit_depth == 16) + png_set_strip_16(png_ptr); + + /* use 1 byte per pixel */ + png_set_packing(png_ptr); + + row_pointers = malloc(*height * sizeof(png_bytep)); + if (row_pointers == NULL) { + fprintf(stderr, "Can't allocate memory for PNG file.\n"); + goto png_destroy; + } + + for (i = 0; i < *height; i++) { + row_pointers[i] = malloc(4 * *width); + if (row_pointers == NULL) { + fprintf(stderr, + "Can't allocate memory for PNG line.\n"); + goto rows_free; + } + } + + png_read_image(png_ptr, row_pointers); + + rgb[0] = malloc(3 * *width * *height); + if (rgb[0] == NULL) { + fprintf(stderr, "Can't allocate memory for PNG file.\n"); + goto rows_free; + } + + if (alpha[0] == NULL) { + ptr = rgb[0]; + for (i = 0; i < *height; i++) { + memcpy(ptr, row_pointers[i], 3 * *width); + ptr += 3 * *width; + } + } else { + int j; + ptr = rgb[0]; + for (i = 0; i < *height; i++) { + int ipos = 0; + for (j = 0; j < *width; j++) { + *ptr++ = row_pointers[i][ipos++]; + *ptr++ = row_pointers[i][ipos++]; + *ptr++ = row_pointers[i][ipos++]; + alpha[0][i * *width + j] + = row_pointers[i][ipos++]; + } + } + } + + ret = 1; /* data reading is OK */ + +rows_free: + for (i = 0; i < *height; i++) { + if (row_pointers[i] != NULL) + free(row_pointers[i]); + } + + free(row_pointers); + +png_destroy: + png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp) NULL); + +file_close: + fclose(infile); + return ret; +} diff --git a/slim/slim.1 b/slim/slim.1 new file mode 100644 index 0000000..ed3de1d --- /dev/null +++ b/slim/slim.1 @@ -0,0 +1,126 @@ +.TH slim 1 "January 14, 2023" "" "" +.SH NAME +\fBslim \fP- Simple LogIn Manager +\fB +.SH SYNOPSIS +.nf +.fam C +\fBslim\fP [\fIoptions\fP] [] +.fam T +.fi +.SH DESCRIPTION +SLiM is a lightweight login manager for X11, allowing the initialization +of a graphical session by entering username and password in a login screen. +It is desktop-agnostic and should work (suitably configured) with any +session style. +.SH OPTIONS +.TP +.B +\fB-c\fP /path/to/config +select a non-standard configuration file instead of /etc/slim.conf +.TP +.B +\fB-d\fP +run as a daemon +.TP +.B +\fB-n\fP +do NOT run as a daemon +.TP +.B +\fB-s\fP +be systemd compatible by disabling consolekit support. This option does +nothing if consolekit support has not been built in. +.TP +.B +\fB-p\fP /path/to/theme +display a preview of the theme. An already running X11 session +is required for theme preview. +.TP +.B +\fB-w\fP x +set the size of the window used for theme preview. This option is only valid +after a -p option +.TP +.B +\fB-h\fP +display a brief help message +.TP +.B +\fB-v\fP +display version information +.SH EXAMPLES +.TP +.B +\fBslim\fP \fB-d\fP +run \fBslim\fP in daemon mode +.TP +.B +\fBslim\fP \fB-p\fP /usr/share/slim/themes/default \fB-w\fP 800x600 +preview of the default theme at low resolution +.SH STARTING SLIM AT BOOT +Please refer to the documentation of your Operating System to make \fBslim\fP +automatically startup after the system boots. In particular, the method is +very different between SysV, OpenRC, runit and systemd init processes. +.SH CONFIGURATION +Global configuration is stored in the /etc/slim.conf file. See the comments +inside the file for a detailed explanation of the \fIoptions\fP. +.SH USAGE AND SPECIAL USERNAMES +When started, \fBslim\fP will show a login panel; enter the username and +password of the user you want to login as. +.PP +Special usernames: +.TP +.B +console +open an xterm login console. No password needed +.TP +.B +exit +quit \fBslim\fP. No password needed. See the note in \fBBUGS\fI. +.TP +.B +halt +shutdown the machine +.TP +.B +reboot +reboot the machine +.TP +.B +suspend +power-suspend the machine +.PP +See the configuration file for customizing the above commands. +The 'halt' and 'reboot' commands need the root password, and hence may not +work on systems where root login is disabled. +.PP +Shortcuts: +.TP +.B +F11 +executes a custom command (by default takes a screenshot) +.TP +.B +F1 +choose session type from session list. +.SH BUGS +When run as a daemon from OpenRC (and possibly other init systems), causing +SLiM to quit can sometimes result in a blank screen and unresponsive computer. +This includes when using the "exit" special username. +.PP +Probably still a few more but I'm working on them. +.SH AUTHORS +Simone Rota +.PP +Johannes Winkelmann +.PP +Nobuhiro Iwamatsu +.PP +Rob Pearce +.SH SEE ALSO +.\" .BR slim.conf (5), ... once I've written one! +.BR slimlock (1) +.PP +See the online documentation at the SLiM web site for further information +on themes, FAQs, etc. diff --git a/slim/slim.conf b/slim/slim.conf new file mode 100644 index 0000000..3e946d9 --- /dev/null +++ b/slim/slim.conf @@ -0,0 +1,124 @@ +# Path, X server and arguments (if needed) +# Note: -xauth $authfile is automatically appended, vt07 appended if no +# vtxx argument given. +default_path /bin:/usr/bin:/usr/local/bin +default_xserver /usr/bin/X +#xserver_arguments -dpi 75 +xserver_arguments -nolisten tcp -deferglyphs 16 + +# Full path to the xauth binary +xauth_path /usr/bin/xauth + +# Xauth file for server +authfile /var/run/slim.auth + + +# Commands for halt, login, etc. +halt_cmd /sbin/shutdown -h now +reboot_cmd /sbin/shutdown -r now +console_cmd /usr/bin/xterm -C -fg white -bg black +sb -T "Console login" -e /bin/sh -c "/bin/cat /etc/issue; exec /bin/login" +#suspend_cmd /usr/sbin/suspend + +# Activate numlock when slim starts. Valid values: on|off +# Default is to not change it +#numlock on + +# Hide the mouse cursor (note: does not work with some WMs). +# Valid values: true|false +#hidecursor false + +# This command is executed after a succesful login. +# You can place the %session and %theme variables to handle launching of +# specific commands in .xinitrc depending on chosen session and slim theme. +# Ensure that the command handles an empty %session, as that is the default +# +# NOTE: if your system does not have bash you need to adjust the command +# according to your preferred shell, e.g. for freebsd use: +# login_cmd exec /bin/sh - ~/.xinitrc %session +login_cmd exec /bin/bash -login ~/.xinitrc %session + +# Commands executed when starting and exiting a session. +# They can be used for registering a X11 session with +# sessreg. You can use the %user variable +# +# sessionstart_cmd some command +# sessionstop_cmd some command +sessionstart_cmd /usr/bin/sessreg -a -l "$DISPLAY" %user +sessionstop_cmd /usr/bin/sessreg -d -l "$DISPLAY" %user + +# Start in daemon mode. Valid values: yes | no +# Note that this can be overridden by the command line options "-d" and "-n" +daemon yes + +# Available sessions: +# The current chosen session name replaces %session in the login_cmd +# above, so your login command can handle different sessions. +# If no session is chosen (via F1), %session will be an empty string. This +# allows the script to handle default in a user-specific manner, if desired. +# See the xinitrc.sample file shipped with slim sources. +#sessions xfce4,icewm-session,wmaker,blackbox + +# Alternatively, read available sessions from the contents of a +# directory. The directory can contain either executable scripts, +# or xsessions .desktop files. In the case of .desktop files, the name +# displayed is the Name= value and the string substutited in place of +# %session is the Exec= value -- note that this may provide a full +# path to the session executable! +#sessiondir /usr/share/xsessions + + +# Executed when pressing F11 (requires imagemagick) +screenshot_cmd import -window root /slim.png +# Alternative using scrot. +#screenshot_cmd scrot /root/slim.png + +# Delay after failed authentication before allowing another attempt +# NOTE: This delay is additional to the time PAM takes to fail, and +# the feedback message remains after this delay. While the +# default value is 2 seconds, it's quite reasonable to set it +# to zero. +wrong_passwd_timeout 0 + +# Whether to sound the bell on failed login +#bell 0 + +# Whether to leave the username intact if authorisation fails. For +# users who mistype their password, 1 is better. +#keep_user_on_fail 0 + +# default user, leave blank to not pre-load the username. +#default_user simone + +# Focus the password field on start when default_user is set +# Set to "yes" to enable this feature +#focus_password no + +# Automatically login the default user (without entering +# the password. Set to "yes" to enable this feature +#auto_login no + + +# current theme, use comma separated list to specify a set to +# randomly choose from +current_theme default + +# Lock file +lockfile /run/slim.pid + +# Log file - full path for a file, or just stderr (or /dev/stderr) to send +# all log messages to stderr. +logfile /var/log/slim.log + +#---------------------------------------------------- +# The following options might be considered better placed in the theme.They +# will work either way; the theme takes priority if duplicated + +# welcome message. Available variables: %host, %domain +welcome_msg Welcome to %host + +# Session message. Prepended to the session name when pressing F1 +#session_msg Session: + +# shutdown / reboot messages +shutdown_msg The system is halting... +reboot_msg The system is rebooting... diff --git a/slim/slim.service b/slim/slim.service new file mode 100644 index 0000000..d58971c --- /dev/null +++ b/slim/slim.service @@ -0,0 +1,10 @@ +[Unit] +Description=SLiM Simple Login Manager +After=systemd-user-sessions.service + +[Service] +ExecStart=/usr/bin/slim -n -s +Restart=on-failure + +[Install] +Alias=display-manager.service diff --git a/slim/slimlock.1 b/slim/slimlock.1 new file mode 100644 index 0000000..d703956 --- /dev/null +++ b/slim/slimlock.1 @@ -0,0 +1,78 @@ +.TH slimlock 1 "January 12, 2023" "version 0.9" +.SH NAME +\fBslimlock\fP - Unholy Screen Locker +\fB +.SH SYNOPSIS +.nf +.fam C +\fBslimlock\fP [\-v] +.fam T +.fi +.SH DESCRIPTION +The Frankenstein's monster of screen lockers. Grafting SLiM and slock together +leads to blood, tears, and locked screens. +.SH OPTIONS +.TP +.B +\fB-v\fP +display version information +.SH CONFIGURATION +Slimlock reads the same configuration files you use for SLiM. It looks in +\fICFGDIR/slim.conf\fP and \fICFGDIR/slimlock.conf\fP, where \fICFGDIR\fP +is defined when built - usually \fI/etc\fP. +The options that are read from slim.conf are +hidecursor, current_theme, background_color and background_style, +screenshot_cmd, and welcome_msg. See the SLiM docs for more information. + +slimlock.conf contains the following settings: + +.TP +.B dpms_standby_timeout +number of seconds of inactivity before the screen blanks. +.BI "Default: " 60 +.TP +.B dpms_off_timeout +number of seconds of inactivity before the screen is turned off. +.BI "Default: " 600 +.TP +.B wrong_passwd_timeout +delay in seconds after an incorrect password is entered. +.BI "Default: " 2 +.TP +.B passwd_feedback_msg +message to display after a failed authentication attempt. +.BI "Default: " "Authentication failed" +.TP +.B passwd_feedback_capslock +message to display after a failed authentication attempt if the CapsLock is on. +.BI "Default: " "Authentication failed (CapsLock is on)" +.TP +.B show_username +1 to show username on themes with single input field; 0 to disable. +.BI "Default: " 1 +.TP +.B show_welcome_msg +1 to show SLiM's welcome message; 0 to disable. +.BI "Default: " 0 +.TP +.B tty_lock +1 to disallow virtual terminals switching; 0 to allow. +.BI "Default: " 1 +.TP +.B bell +1 to enable the bell on authentication failure; 0 to disable. +.BI "Default: " 1 +.SH BUGS +Where the theme defines a welcome message or password prompt, \fBslimlock\fP +displays them in the wrong place. +.PP +Using the same theme as \fBslim\fP assumes the theme is appropriate. Most of +the themes out there (including our defaults) put the word "Login" on the +panel, which isn't quite right for a screen lock. +.PP +To alleviate both of these, you can specify a different theme in +\fICFGDIR/slimlock.conf\fP, which will override the setting in +\fICFGDIR/slim.conf\fP, but you still need to find (or create) a suitable +lock theme. +.SH "SEE ALSO" +.BR slim (1) diff --git a/slim/slimlock.conf b/slim/slimlock.conf new file mode 100644 index 0000000..61e02fe --- /dev/null +++ b/slim/slimlock.conf @@ -0,0 +1,11 @@ +dpms_standby_timeout 60 +dpms_off_timeout 600 + +wrong_passwd_timeout 2 +passwd_feedback_x 50% +passwd_feedback_y 10% +passwd_feedback_msg Authentication failed +passwd_feedback_capslock Authentication failed (CapsLock is on) +show_username 1 +show_welcome_msg 0 +tty_lock 0 diff --git a/slim/slimlock.cpp b/slim/slimlock.cpp new file mode 100644 index 0000000..5b60726 --- /dev/null +++ b/slim/slimlock.cpp @@ -0,0 +1,342 @@ +/* slimlock + * Copyright (c) 2010-2012 Joel Burget + * Copyright (c) 2022-2023 Rob Pearce + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // for usleep +#include +#include +#include +#include +#include + +#include "cfg.h" +#include "util.h" +#include "panel.h" +#include "const.h" + +#undef APPNAME +#define APPNAME "slimlock" +#define SLIMLOCKCFG SYSCONFDIR"/slimlock.conf" + +using namespace std; + +bool AuthenticateUser(); +static int ConvCallback(int num_msgs, const struct pam_message **msg, + struct pam_response **resp, void *appdata_ptr); +void HandleSignal(int sig); +void *RaiseWindow(void *data); + +// In the absence of a class instance to contain these, just make them file +// public, as they're needed by multiple functions +static Display* Dpy; +static int Scr; +static Window Root; +static Window win; +static Cfg* cfg; +static Panel* LoginPanel; + +static pam_handle_t *pam_handle; + +static const struct pam_conv conv = {ConvCallback, NULL}; + +static CARD16 dpms_standby, dpms_suspend, dpms_off, dpms_level; +static BOOL dpms_state, using_dpms; + +static int term; // Used by a C callback function + + +static void die(const char *errstr, ...) +{ + va_list ap; + + va_start(ap, errstr); + vfprintf(stderr, errstr, ap); + va_end(ap); + exit(EXIT_FAILURE); +} + +int main(int argc, char **argv) +{ + if((argc == 2) && !strcmp("-v", argv[1])) + die ( APPNAME "-" VERSION ", © 2010-2012 Joel Burget\nUpdates © 2022-2023 Rob Pearce\n" ); + else if(argc != 1) + die ( "usage: " APPNAME " [-v]\n" ); + + void (*prev_fn)(int); + + // restore DPMS settings should slimlock be killed in the line of duty + prev_fn = signal(SIGTERM, HandleSignal); + if (prev_fn == SIG_IGN) + signal(SIGTERM, SIG_IGN); + + // create a lock file to solve mutliple instances problem + // /var/lock used to be the place to put this, now it's /run/lock + // ...i think + struct stat statbuf; + int lock_file; + + // try /run/lock first, since i believe it's preferred + if (!stat("/run/lock", &statbuf)) + lock_file = open ( "/run/lock/" APPNAME ".lock", O_CREAT | O_RDWR, 0666); + else + lock_file = open ( "/var/lock/" APPNAME ".lock", O_CREAT | O_RDWR, 0666); + + int rc = flock(lock_file, LOCK_EX | LOCK_NB); + + if(rc) { + if(EWOULDBLOCK == errno) + die(APPNAME" already running\n"); + } + + unsigned int cfg_passwd_timeout; + + /* Read configuration and theme */ + cfg = new Cfg; + cfg->readConf(CFGFILE); + cfg->readConf(SLIMLOCKCFG); + string themeName = ""; + string themebase = ""; + string themefile = ""; + string themedir = ""; + + themebase = string(THEMESDIR) + "/"; + themeName = cfg->getOption("current_theme"); + string::size_type pos; + if ((pos = themeName.find(",")) != string::npos) + { + /* input is a set */ + themeName = cfg->findValidRandomTheme(themeName); + } + + bool loaded = false; + while (!loaded) + { + themedir = themebase + themeName; + themefile = themedir + THEMESFILE; + if (!cfg->readConf(themefile)) + { + if (themeName == "default") + { + cerr << APPNAME << ": Failed to open default theme file " + << themefile << endl; + exit(ERR_EXIT); + } + else + { + cerr << APPNAME << ": Invalid theme in config: " + << themeName << endl; + themeName = "default"; + } + } + else + { + loaded = true; + } + } + + const char *DisplayName = getenv("DISPLAY"); + if (!DisplayName) + DisplayName = DISPLAY; + + Dpy = XOpenDisplay(DisplayName); + if ( Dpy == 0 ) + die(APPNAME": cannot open display\n"); + + /* Get screen and root window */ + Scr = DefaultScreen(Dpy); + Root = RootWindow(Dpy, Scr); + + XSetWindowAttributes wa; + wa.override_redirect = 1; + wa.background_pixel = BlackPixel(Dpy, Scr); + + // Create a full screen window + win = XCreateWindow(Dpy, Root, + 0, 0, DisplayWidth(Dpy, Scr), DisplayHeight(Dpy, Scr), + 0, DefaultDepth(Dpy, Scr), CopyFromParent, + DefaultVisual(Dpy, Scr), CWOverrideRedirect | CWBackPixel, + &wa); + XMapWindow(Dpy, win); + + XFlush(Dpy); + for (int len = 1000; len; len--) { + if(XGrabKeyboard(Dpy, Root, True, GrabModeAsync, GrabModeAsync, CurrentTime) + == GrabSuccess) + break; + usleep(1000); + } + XSelectInput(Dpy, win, ExposureMask | KeyPressMask); + + /* Create panel */ + LoginPanel = new Panel(Dpy, Scr, win, cfg, themedir, Panel::Mode_Lock); + LoginPanel->HideCursor(); + + int ret = pam_start(APPNAME, LoginPanel->GetName().c_str(), &conv, &pam_handle); + // If we can't start PAM, just exit because slimlock won't work right + if (ret != PAM_SUCCESS) + die("PAM: %s\n", pam_strerror(pam_handle, ret)); + + // disable tty switching + if(cfg->getOption("tty_lock") == "1") { + if ((term = open("/dev/console", O_RDWR)) == -1) + perror("error opening console"); + + if ((ioctl(term, VT_LOCKSWITCH)) == -1) + perror("error locking console"); + } + + // Set up DPMS + unsigned int cfg_dpms_standby, cfg_dpms_off; + cfg_dpms_standby = Cfg::string2int(cfg->getOption("dpms_standby_timeout").c_str()); + cfg_dpms_off = Cfg::string2int(cfg->getOption("dpms_off_timeout").c_str()); + using_dpms = DPMSCapable(Dpy) && (cfg_dpms_standby > 0); + if (using_dpms) { + DPMSGetTimeouts(Dpy, &dpms_standby, &dpms_suspend, &dpms_off); + + DPMSSetTimeouts(Dpy, cfg_dpms_standby, + cfg_dpms_standby, cfg_dpms_off); + + DPMSInfo(Dpy, &dpms_level, &dpms_state); + if (!dpms_state) + DPMSEnable(Dpy); + } + + // Get password timeout + cfg_passwd_timeout = Cfg::string2int(cfg->getOption("wrong_passwd_timeout").c_str()); + // Let's just make sure it has a sane value + cfg_passwd_timeout = cfg_passwd_timeout > 60 ? 60 : cfg_passwd_timeout; + + pthread_t raise_thread; + pthread_create(&raise_thread, NULL, RaiseWindow, NULL); + +#if 0 // The DM code does this: + /* Init Root */ + LoginPanel->setBackground(); + + /* Show panel */ + LoginPanel->OpenPanel(); +#endif + + // Main loop + while (true) + { + LoginPanel->ResetPasswd(); + + // AuthenticateUser returns true if authenticated + if (AuthenticateUser()) + break; + + LoginPanel->WrongPassword(cfg_passwd_timeout); + } + + // kill thread before destroying the window that it's supposed to be raising + pthread_cancel(raise_thread); + + LoginPanel->ClosePanel(); + delete LoginPanel; + + // Get DPMS stuff back to normal + if (using_dpms) { + DPMSSetTimeouts(Dpy, dpms_standby, dpms_suspend, dpms_off); + // turn off DPMS if it was off when we entered + if (!dpms_state) + DPMSDisable(Dpy); + } + + XCloseDisplay(Dpy); + + close(lock_file); // will inherently release the flock + + if(cfg->getOption("tty_lock") == "1") { + if ((ioctl(term, VT_UNLOCKSWITCH)) == -1) { + perror("error unlocking console"); + } + } + close(term); + + return 0; +} + + +static int ConvCallback(int num_msgs, const struct pam_message **msg, + struct pam_response **resp, void *appdata_ptr) +{ + LoginPanel->EventHandler(Panel::Get_Passwd); + + // PAM expects an array of responses, one for each message + if (num_msgs == 0 || + (*resp = (pam_response*) calloc(num_msgs, sizeof(struct pam_message))) == NULL) + return PAM_BUF_ERR; + + for (int i = 0; i < num_msgs; i++) { + if (msg[i]->msg_style != PAM_PROMPT_ECHO_OFF && + msg[i]->msg_style != PAM_PROMPT_ECHO_ON) + continue; + + // return code is currently not used but should be set to zero + resp[i]->resp_retcode = 0; + if ((resp[i]->resp = strdup(LoginPanel->GetPasswd().c_str())) == NULL) { + free(*resp); + return PAM_BUF_ERR; + } + } + + return PAM_SUCCESS; +} + +bool AuthenticateUser() +{ + return(pam_authenticate(pam_handle, 0) == PAM_SUCCESS); +} + + +void HandleSignal(int sig) +{ + // Get DPMS stuff back to normal + if (using_dpms) { + DPMSSetTimeouts(Dpy, dpms_standby, dpms_suspend, dpms_off); + // turn off DPMS if it was off when we entered + if (!dpms_state) + DPMSDisable(Dpy); + } + + if ((ioctl(term, VT_UNLOCKSWITCH)) == -1) { + perror("error unlocking console"); + } + close(term); + + LoginPanel->ClosePanel(); + delete LoginPanel; + + die(APPNAME": Caught signal; dying\n"); +} + +void* RaiseWindow(void *data) +{ + while(1) { + XRaiseWindow(Dpy, win); + sleep(1); + } + + return (void *)0; +} diff --git a/slim/slimlock.pam b/slim/slimlock.pam new file mode 100644 index 0000000..7b88c2e --- /dev/null +++ b/slim/slimlock.pam @@ -0,0 +1,2 @@ +#%PAM-1.0 +auth required pam_unix.so nodelay nullok diff --git a/slim/switchuser.cpp b/slim/switchuser.cpp new file mode 100644 index 0000000..ca936ae --- /dev/null +++ b/slim/switchuser.cpp @@ -0,0 +1,74 @@ +/* + * SLiM - Simple Login Manager + * Copyright (C) 1997, 1998 Per Liden + * Copyright (C) 2004-06 Simone Rota + * Copyright (C) 2004-06 Johannes Winkelmann + * Copyright (C) 2022 Rob Pearce + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + */ + +#include +#include +#include "const.h" +#include "cfg.h" +#include "log.h" +#include "util.h" +#include "switchuser.h" + +using namespace std; + +SwitchUser::SwitchUser(struct passwd *pw, Cfg *c, const string& display, + char** _env) + : cfg(c), Pw(pw), env(_env) +{ +} + +SwitchUser::~SwitchUser() +{ + /* Never called */ +} + +void SwitchUser::Login(const char* cmd, const char* mcookie) +{ + SetUserId(); + SetClientAuth(mcookie); + Execute(cmd); +} + +void SwitchUser::SetUserId() +{ + if( (Pw == 0) || + (initgroups(Pw->pw_name, Pw->pw_gid) != 0) || + (setgid(Pw->pw_gid) != 0) || + (setuid(Pw->pw_uid) != 0) ) { + logStream << APPNAME << ": could not switch user id" << endl; + exit(ERR_EXIT); + } +} + +void SwitchUser::Execute(const char* cmd) +{ + if ( chdir(Pw->pw_dir) < 0 ) + logStream << APPNAME << ": unable to chdir() to user's home: " << strerror(errno) << endl; + logStream.closeLog(); + execle(Pw->pw_shell, Pw->pw_shell, "-c", cmd, NULL, env); + /// @todo this copy-paste of App:CloseLog() should be cleaned up + if ( !logStream.openLog( cfg->getOption("logfile").c_str() ) ) { + cerr << APPNAME << ": Could not access log file: " << cfg->getOption("logfile") << endl; + exit(ERR_EXIT); + } + logStream << APPNAME << ": could not execute login command: " << strerror(errno) << endl; +} + +void SwitchUser::SetClientAuth(const char* mcookie) +{ + string home = string(Pw->pw_dir); + string authfile = home + "/.Xauthority"; + remove(authfile.c_str()); + Util::add_mcookie(mcookie, ":0", cfg->getOption("xauth_path"), + authfile); +} diff --git a/slim/switchuser.h b/slim/switchuser.h new file mode 100644 index 0000000..49a1215 --- /dev/null +++ b/slim/switchuser.h @@ -0,0 +1,45 @@ +/* SLiM - Simple Login Manager + Copyright (C) 1997, 1998 Per Liden + Copyright (C) 2004-06 Simone Rota + Copyright (C) 2004-06 Johannes Winkelmann + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +*/ + +#ifndef _SWITCHUSER_H_ +#define _SWITCHUSER_H_ + +#include +#include +#include +#include +#include +#include +#include + +class Cfg; + +class SwitchUser +{ +public: + SwitchUser(struct passwd *pw, Cfg *c, const std::string& display, + char** _env); + ~SwitchUser(); + void Login(const char* cmd, const char* mcookie); + +private: + SwitchUser(); + void SetEnvironment(); + void SetUserId(); + void Execute(const char* cmd); + void SetClientAuth(const char* mcookie); + Cfg* cfg; + struct passwd *Pw; + + char** env; +}; + +#endif /* _SWITCHUSER_H_ */ diff --git a/slim/themes/CMakeLists.txt b/slim/themes/CMakeLists.txt new file mode 100644 index 0000000..9eee86c --- /dev/null +++ b/slim/themes/CMakeLists.txt @@ -0,0 +1 @@ +subdirs (default original) diff --git a/slim/themes/default/CMakeLists.txt b/slim/themes/default/CMakeLists.txt new file mode 100644 index 0000000..5860362 --- /dev/null +++ b/slim/themes/default/CMakeLists.txt @@ -0,0 +1,5 @@ +set (THEMES "themes/default") + +install(FILES slim.theme DESTINATION ${PKGDATADIR}/${THEMES}) +install(FILES panel.png DESTINATION ${PKGDATADIR}/${THEMES}) +install(FILES background.jpg DESTINATION ${PKGDATADIR}/${THEMES}) diff --git a/slim/themes/default/COPYRIGHT.background b/slim/themes/default/COPYRIGHT.background new file mode 100644 index 0000000..83a03e1 --- /dev/null +++ b/slim/themes/default/COPYRIGHT.background @@ -0,0 +1 @@ +Green glass image copyright Rob Pearce (c)2022 diff --git a/slim/themes/default/COPYRIGHT.panel b/slim/themes/default/COPYRIGHT.panel new file mode 100644 index 0000000..d219b0f --- /dev/null +++ b/slim/themes/default/COPYRIGHT.panel @@ -0,0 +1 @@ +The icon in the panel was downloaded from https://icons8.com diff --git a/slim/themes/default/LICENSE.panel b/slim/themes/default/LICENSE.panel new file mode 100644 index 0000000..d60c31a --- /dev/null +++ b/slim/themes/default/LICENSE.panel @@ -0,0 +1,340 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Library General +Public License instead of this License. diff --git a/slim/themes/default/background.jpg b/slim/themes/default/background.jpg new file mode 100644 index 0000000000000000000000000000000000000000..98233f5baeceb2a8e18ecf1e22a1cda1abe5693a GIT binary patch literal 278157 zcmeFZd0bOh*FSm^AcPP!i2)Nt8$!Sk0m+1dLjxo+VXz?tB#0Ks00fyqg{SQs5D-GZ zBn%Qng$NiBD5HWyi;Bn$GC5mEP^orM+s6)%_h4so<%KX}nVj0N*4@WMb%fTeOM z__G4Uf69zIX!;({gJq5dA27)H&;$SylG2k>llDXbKp=<++X!T4uruHSR$Z$7XTFUe zC?L?>sP1lb8rY^gjpjwAdAWNKXjCtTrx%S5tO2TW{?J?mNh2Dy`8Pkb<`0kIFko9Bunu%TqYe02*Wu()yS51k+ME4g9mz z^N1z^p)&0Mvd4fH@$znkZL=GlL0b|6v9Pc}S|V{)Rydly zojvXUIKArw&~Ts+0vbyMplFB*8uG3m_z2X~Z0RWpdGD(wW5CI6Y6dfhTOce!hHli7 zr%a%xCT3=)py`m$mnOd{+6-e)^@gnoiZUmrU}@RfTDXHx`$cQvweLyv=+qnwgw0AE z-qz7+E!mmEV0vuW=;`Il=5V+1_3M5?A^CNGwVQZUjD&? zLY1zxti0lIrM}8=qOQK-q_MH7qqD2~^qHRCvzIRSUm3VMI5a#pJu^FZ{l?8(4<0^x z{A7ON>9glQ{P^nio1cFE=i6VF>{_z(&$MLK|IIEmXcyGf)Wp<$$u0x|=&*wr}mOINIBI zk(4#VSjn&&UG+s6>u1J5Pv9K_tSP%%UWeG?oO&Zr_x4+kr@XXgBlb!}GHhGDpK*(` z81eYp1hK@n`i$F7yeGC#C<+BUL{_j} z9_~BAGbf?G?&tQl@!4^z_F~fuX6J#g+|R#h`rLDibF*bCmv!RiZTY3||Iy#`#o*05 zN6LQC#CydicoRHCKRalH&OO+^e9ar7{L;dfc-}z#i)AyvTBO9AZ`%2$DJgc-)-4>D zX1|o5FQf@FpYWIQar0fD=>8M03ct z&t~_nExp%b=T0b5oTF&CnQxdpPMVWf&gV^-{x{Z9WjQc2ZvvCWz4?o1`J$@wl!R${ zAXMeRxcvI0CXkxHB~7H1d>)tktFS75^(7;$RQv3OD(d0UdsTNc8|c#*cZD?9l}YbA zMaE_js_rM~#fZ~y7aXimXqF!pM*2Uaz;aRZD8biajL%n^c(1x=M zXIgxZr=)ghioV{i2zyBSabpYijGzaq>96^GdRtdOe$~1Tt8AY`S&?UCTQ;6j0smT| zI--!&o=m3Cx%{A#+?Ms=T13UmzyDW=U5@)$N!;B$eZ}`4ES#~vaQ}>qPwQv}bzDbsHK80*^?*WNOGqg6@T$N$T=u=>lnX30qTMkj+Ce|&$#;R%u`VdLFm zL*?>JShB(?Ig>Hh^A3Woup<4c9LN&88|{Wq;n(ujaa zAoF$OrO0(zvtb9{0j(|T@8XPT8svJycJ(KBAJ(wfsvq5I5Iw?HS>KdZaSBox-8aF+4oHF?5B?yyPwW* z4#oBTrZ^SeeB?;-;*D9nQ~II&KBLVK8oS3;o{E+_H$UNzuKqCu?g0Ed@pRbWnZSu-3Dtl((~+s%Ag|#z$F6evw(} z|Mgu+o?u(}N%+<9YAWtwk662R>oWR|2ZZdYj`DG@5MxBPD&MKNVEDx&{HYY;88hxW zk2@vwogRZ0cw$FsTltWryI6@kmGW%x?)P7GwbzVqQ(QpgT%KyrK)l74R4o7Hbkp?B z&7XI^ZZ(i4CJfy+i_KTH&$e3!OZnBC+XlT??FXkM^s3Fymc7%i?ZU0&xZl^={4&QB z`jx~RFrTD3i`oYxDlR_Gvo7^~*>L7NiEEEpv*-1=U%RJtPeqi7kz+o##^J~NTJS$D z;E0_vla$A^VK;fruQqPBjqH(a?OKSa%In$Mm1>x|x%Sp}8f(mb>}sOI;Xt(za+`RV zvcBq3;rMn6eX9QE@rU?2_piK6{s}Hm7*n$j?03Lj<8aUOZXW!`{0XOe%AMaDP7r2+ z%R$Gic)p0JPzUgdk~!vHvLE|O%cCuyt3>NQ35V+TH?DTiH2(C9ZDbZ^I4h*`n|CyuOQY(E$mi=hrWaXo99xkM}E2{ecbrlx^V1n2q|O} zpY>~B==(EFyUM<={#`Nh^#1qCM~e~T zL0Pt`BemOC)d%TdDZwqnI{w3B>4!}qsg(1lI|hn>eD#|r_Cne2(Zh~EX(Ra%0q=3i z?D2nCojYTmwkD^xg0H+$^EiVLx_b7vq8^O*v#O^3;b+cj>M6@>cHgek+DVc(wkm#^ z6=-;4;@+=I@k6ic2vi2+v|Ta@VS2bepqVe!%lfo>6M6z2kq)v=e4BB>ps=L z6bJh^29{PotjQQi3)R0}91GPv*4}I3mk+a^f1H~V)V8MF>E+B-!M4?k)=lV-6j83~ zod5DV9D8vhy!h}}akW}TiTOQ7&W@}17(Z?IdKFYo2(d4^kp1h-)WVjyuc_mZM=cKM ztJuC2l6u;5jk9F}t}YsyvwUqgL+R81J%^sTJDE&+m_6wEVvJg_oy)2XGy8b`)~>0m zICE7LDcJI8{~k_6-f7hcKP~irO7)uZ(QAb#@Scm|9t&#q!jy66)t=;d`S{R{mynVz zl$~t;;TI-tR#RtO6CbNTzb0x)sE0!$OkV7)xD||>z41{^vmwc; zAMM0go%C#W9IfBK4)ws|T;;yGM9Y}X>CMg$Wt*>W%P?~Ll*{Kj-0+`nM$B0szr|`C z-h`tqthEdASSStGUDSMnoA4IhbAy{o=bi`2oUR?WH=a@dNSW^Uc4%z+Zp}o*eA8fS z^h!IO8K*aIJGNrJ3bMRMa^POkvd6BvtYE~k{05Eg$|2GlCf?3gLX4U$y~4G42fUd% zh(8HG5%qK1f0YXcX~~(7E^v2PuXD4wI6S?)-rYX2YgCHaBx=t6+&MQUTLi7}#YNoz zxxpRRw{Y+9$erXs2P;G6%WaeMns%ns73xdZiF$g{=JW=0q4Eu$sn`mi@XNvELc@Ni zOy0U-88JFI*|ir5w4U~;;S~T2wslQvsOI#@s75n7nG zX8Pir)^)ok>vzaYXqQhrkLPWQc-1sezq0jI@8vr@Zt{NX4t$J)(2LVjsy@hNq*AwJKfhBPCD zUM9_^_NUv;{DTqO5HM=@gJ7e%CetW&J9%KthqOnN8pyOczzuXTyJ|OWj+X}?Qp6?i zTw5*N{N!Jp`-rTARDrxzy9}^ zTjFv;S3g$-cR7hCq%xtvS+X0DOoFvies zzqrM@>sr(j*ERWO@ajQO{;Xs7t;oJMpDM)jW-1U%Ga) zyo*r%!vwP!k6%=M9jhB7^ZMjl%n-}A59;}xUEikfJ@Jj5&9Qxd+qu71<^bWFUx*SO;-hT~TVp$?_iPpnLWd4y?@Zo*?C$MV*|;}flKihm zAQ!Bot=I=I^Upxri=Bh#tWJdNYMJ{xh;yFRI7Lw3P$6pNk7`cDGnRj4w z$X?UbtdNGvm+Wu7_SNN;i;H5i2e!nGt$C@S{R#=O%bISFQ}1=_uPUmZuik007;tBs z-(JeY!y5-OnfQ&^#DVS3=PvIxTufQ@=x3%Der@ ztSNVy-48Fe!>YdJFH}j|*X*ymyXeQ;Ix`&*Bhtl~Gq-;G<7MWtgHZ#Dpmj*(4-r36 z-SUJRney?>7P&Y&8c{tL-8;dQd!921^f-ErrqXrZc(ZHW!%vPTR-DZ{+mYR+9p5%N zd$XCbdcVH;iOs7uBa{EKeuDnkb8PpS3;)<>WtaC!d-IbuF<&%%R^2rC?9E5ZKMkY1 z_qQK<_{sOpo}}0tFDD+ZOT2s~bs)!6sr{t!)QYi_3jgElCAP(q9=l5c=3`?Hj z%w~PZOMh!fIg~ZjqY4|iZkMI%mNO1^KU!uY4H2&{yxTKxAbt6nNFF@-rm3A5I<(g6 zc(}6HCv&2~xpiT)tpxSSYI6IIHEuhrOI5{k$C9k9nN*Y&L1TRtS1%12VK?HPYCmsz z-84G7jIIr&wc*BW)}{JTtL;>I7qL$&_Zg37f9(7lMbpe3WKBF1v_(xQj%0dH_(|+k zU7OH0W+{Q2fAAA6E2~D&H3FA4aShem7*o#b#BDA3`de1+>NQ<`blw+=;46%_nphv_ zufzAoEoTfQRo>*0K2l^I^BfCPJ@&_O@vj*-iIlWM!@b|#=`Zlu-#DE;wj-*f>`7|! zrfGE6hM`4OTL(n+VCx0NaO_PI|!3+^7;@Mu;V zg1AaN(R-GUJsv)|0=X=fE)}H~6UD!s-cGF=PnifWp9i8(@!mEFrY>(Zj-;kk3p0kbcLIO$#MajXntFajRl!0-+)ant z8ck+{GHGmao2f9S$_KJ=!5w|@0v-1=_Q!vq0~rJM^GE!rbd{^9y}@UGJk>s-F$qm! zQqBaFhIL8DR^U>~nHJpO1OF7oQMY@aT9>M8y=nd^xCv!{ACuX5?bURZ@#!}5%{u-n zBO_13K099(_PGMMcs0US0B2a1V_@(!zaNzpqLn)|Yc?Wu^|=%$gWU2elQ0n=5+Z-t zK2%n)x+Lyc435#7oUB;8`l?^3E5-u8XU*s2q$6L#YL|ImUEChCB})}b7TnP&HazI5 zUrRi4>}m_Rg!#3Yn!Va z!wz`@qV7@Y_GbYa^x!kU7Ol#Z=eTb16S3#uN8x$iTVj#keT|Xf7}QN@!-~k)O;JDn z)MzrVX%7FD^>iC{E-|$m_M1A`xBUL3&DvMXeFI!?RZeJwzWX+7a%<4bbNLhu{Ju)# zUt+cFcG;oueb!Z!jz`aUtIjCO8XaJ@4t8tGIZmc89;cs7zGMLMAOGMz_*fu#$h$xN z>G76L#yXNM5F2%`OqmHg9JLuz1;lptei6(h2r=I#m}TkNF~K^du1xtEa5{U8Cn+d}-H>b`yZ-1gDkl2T*V zQ$0OB*Spi!(`c?Bhih79VtUkm*Tgi3KP9kbX_C~qpi4OrF6O6gXS6~p;BEL9#pz(6hlgPrMiRr?o^q4Lli^y zryPD_T6$EXM7AUcl&aYRN@Zj}7j04?5jr1A|GU zQmG#}LS?CG;J{cC_5N^)NRUdrxS*gYu$SW!qGDw070I%g_sV@NPrbX?QNr@kblGv!k7#TQE!LjlOTik!sbnnCk)jiN8P+jHXvsR!t*KkBC?$TwvbI~Z=1n4T)!=0gBa;|b>TU<4EljMD(arJ^Kh$=(7%z#k{) z|J~o8=9a=60ASj6N!EYI@juY4q~J>kcp^^#d03L<)N~L>g4knUdh!yk1Thv|ut`DO z3}Tm5P(cviSfWS&fxlhCG4JvFC>(66NazdNh6U+_n7`rZzhOyiY68f!6h1HdGy zq7MVWnS%g;yO|u78uh-NrAQa391N5D@gx9Pi2-26BpA}P^AEp)WlQD2iR)n44Ct$X zF#yn40f18sC_CbRWA{?5-CutDA9+6b?|sOO2^6~Y3no+W*9^WCd}4+$H;2KI2qe-H zVQFc#41=;-hF)fAiLybVS75EJt&z)D;%u-u4AvU^K4iuOtYd0sVP4zOH9_s#wVwCr808Au;pj(U@ql+1TZT6lX{wc`Y^LcifB%E(_uiJO`)6oK8DcSl*9>K_f;V z8WeGWdWLM|`gRZGo2q@$8MQDu7%?MIp^8YVg>X{UB-aP1vtQQU6xw^!*<<*o8HRVz zn@|Jy=9tc44N!ojEr@3lXoVa|SolDF zK}u~Dq_$B^tpW=16Cpy4@HK)+sEgOe>)l7ZtcVhv(eH3$BJ(gl(J^xLnS9!ACJ~=7 zj-S07f)?PQv3rMZ7naD+W(*bC*-j)(cywMqKmNm}fvN!;;gz&!hkZL4yNdHZLjq2a4$(q z@H1JlB|tHTJVEo*benZV(1iA7+@0!jecZmWn~9FnYZ2Mw&U@E;eBW5V;r51S^Z%5b z3N6>~-?8Z{aF1oZPo%!{8FeIW)dX{VRlj)Jky!fGLTT_s@6oi&4Z9z9xLgSQMY3!4 z_0n^f&s{xdopt1CsO?-<&)pce4dRk`o42a)!_+yhqJo%D&Z()e3=NR-*Hs=QQ`I`e zhSo@ulB6rJ7L$OIM-D1&dI8!8RbaH{-HH#jE})=IP|w*=JOE)C8*23c6=PPw5t3M9 zi93P9ViBNR>PH>F-9z^K;A?B{=ZA;E=Ui@BSq`5Nl;oX1T`rqGf*4|KP_tAE5pSwn zcahrYoyYWz^tz}Nm}$aMjC)0*2a zwA~8m7qzddBW_zYlG|cWZ|YstKdDT~@4g!`>Xdoob=bL0!9_`%&c8Z4c;~2Ollt`V zeEL7q?b3HR_T1gxT_o;?pF*74)zex8WzaEw^OblD&eM(NWLmL5l}>F0Xs7~Q9uFqg zPDQ59%mPDXQ@%9=V`Z5h3PoXPWGD+}57*}BAqEM)Xo8?G9b*b$?3d-R0e6CxdgA)O z_5t=-dayv18(U#tb(!4h(-BmMZjQKsrpB}N7`X{O;9E+_jiGvxzMz)qS3@STxoxA| zSOxJ>kS_zhLfo1k!(#gf$-?FRt<0SQN27v+W;S>wxY3?oz&B<-vCmE!Oeck=F09tG z)1PeH;umMv5X?BNf9`Z)&061Q$5y`@f3(vJS9B~Pfa%$MJ>ZS!j=9x7r}P6Fcq9!$vPn4S2&)YV zr0Vz@BW^I9#aSVqBI{aeNZee#hS&%`HTh6TMTi5DZ3g69Ykyri_CR!B<bLp5*C`<~Jtigq=BPD5M_*R~HtIeJDwk(OVR-Op2sV9% zKxz*$Dsw3DKYeuMvhd(Cybr|-f+pq%0elXJd+`$@S>sCb#q|gIkSOKUts1j?qshchJ){U7sHIMe& z7*V;foVDNvIu-?w;5Ovx z;!WX$c&7s{eYK{cRdX>LvAffR?&wAdy0VBt&yS_~aXt4$x|5foSEJ91Yhg}fep7;q zkPgoqW^du&Ir+>;c-p#+Bj(D|b931a` zr}`9in>eqxA>c&I{_(Df;N!uJ%fXwx5S~ryIFX}%CRo}n%#VpHppz|1g+urn1gX2W zOl)p36=#c_^6XDvN4J-yL%DvI(w$HjAKRQV*Oq|mJ;jt!u-yo#@UN|^nJG&D2R?3qWP1LMZ)3(5PGxo}D@04S zA!{M+&_XkL!wIwlRQ>Qix_0d*;aOXhcO%y+_oj8E+_A3RKe?qSk?7f^m=Q)qVMET{ z&hAeT&qX_OG=$M?+nxPEnqj+Gf$EGtbF^>SWnVqj?^LVePCqyO+jCBJ%c64@EJ+5w z(*Ymk@M@UUHk)W2$U@B+d7?>o02=RAE)|mD(89I62EZOrvXxi79mp(kAxSB4M_I-C zAgb8v6K}peGCv8UnF4}odT^{!7q|^;@55k{D>+p!l_<$0sXxs@!ZdlCmqW|*O9Q%QVs#Hfna`p*tjr#6M=;a(RP?R1ouTj(?{p*;`e zMh41Z`B6gRAS$QBZ0`^vH-tlgm=P6xf%Zr!%bVazH2UBy%-9&(rB2kCC0Y+9nDejz zS*xQ&J833vY)z^JU+Gvu&W=^qrbHFKZlf=0vb_(A>gyEZV~5G!TH6|V7hn%*Y!Vzq zM&lk9;rhdC&{_w=Q^;jy`&@=8+_#vhB9=#{RdpMl4(hWLnDZtQhqB3)#!H<{u{+J0 zn7dmay3Vo?7GFE-z4lmIX!?C-JToSUPmrhK`zK?wI^LctG(}5;z2L?suTgQAZhLqW zjB3ZMwBZfa0YpHT*f3+SvBqMkd6W}$M?lwD!6&#nWy1}@?%{Ok0LLD}ftX?lt9dR3 zCwyRh=xQ(N@wVT-p+RA^VzxWDOeEIA+n6~J_?@n@N?&NjoG!?*VA8Z4*%RbIt`Vd8 z5{45#(mg*Y8qxySK~T2vrz+dQ#!5^TP;Z4C51(tNGj}1_Qt6%xT$l*~sP8VdUFp~n za0Jd@#a$e4)IZ9E&(ShK(#E=iEQ2g-y;W?8zd(}%m^a; zBN#qlA5t*>b=2Fhq+v<~gA~p3VHQWhC)@iua6|uS&Bof|rf|8y#gI+1GS?|NHo`$2 zYgtZ|tt~Q$gS9UVgU9AmQHkPsCnuSsS|0C+Nu8;Hd!JTp^Oj@y;R0{>g2xe?Vu_YC8sgtm0I32*q`BdtiH$iOm z1u~2`NBHI3)+D`cLAG*|?28*IQkk%@VOOy{I&WAB5%YZkJn!l<5&^0LAZ1W5d-!BD ztEavlj|!@l3aBiFK#k0g4dT{SW*5ubO#JaIZ=;(DJ*>sP5F91*}-02MARsl(z1p~WSs z0Oio!zxL@Xh%l1&2*!jw#ZVp)7P=S(efSk=VcAH-2%3nFEvBUau~Z##7+=dii~?v= znsT>#j66DhWyA@l9l^w%NoPQZ(b?9O*HM8mMOXo0NIa=C)488fUo`G$D2K6kYMlZ?_Ou5Kbrej|v{u7*2UDc)?9p(4*A4briM|ZbdQW1MUd9 zm1782X~PyrTWbX@WoS7G$>x9Q=HZ0VY_a!Zja9zP%?k zVF!ii&B|>pTqz!y$7h`iiFO;?7=F-NwIScEe;_?%kW8xNu|BIbhyS*tk+A5=m@z85)(AQ=U^oQe&q=GK4~cNb+>Lz=T^V44AI+* zItY-0s%UFDrIU)RV#P{XW(7breJZX%V;|&$LbI+c%Z5i|@=&JAX9e1i+CKY+W;$tQ z*_xGea20FJvFd=>mEI(Ws#GQtp*fZ}K(&=VOwVYQ6k~Ke(g|;r;hJO{!K}=iVGk`bmK_0~M_x@?3KG_z*xG<7wiw$T=P34V3wgF*KzhX4jge>tWwz=L) zo~PMc%LIByb!P~IT-HA+bA@+0K5&T=t8e1R{fzC{MD^g4Gb=(Cs8gqctWw;Y$L00u zO$~Hf&W+|#b|iEc-!m{D?8aKyW4lL~A^ns)rA9T{-#-(nfUyxZ(Ris^H`>R(g;g)a zhSRJ=9JTOhbfjGQ+*!j5CWSa+`A2ywyrXDEFpt%oGFbk@?5kKFhgd?VU^a9%6@ySJ)GN*39KnZ^_lUs$2)#& zMRt|)dZ4z{dSqE#T)kI8a(|WE0pOIij#fxcY2-o7uE4ttDiz(msnlB|oP_HFtsY6E z%UkOPxDvyqAya7u)g{|N%R_c&FRRh{A^K}8^=_JLwyqcgy*6^7Gr}}(hp=AWwoVo_ zBoyadp}V`=r;!1J>tNmuZ570va)oEZS|Q?-N_j|sG&|dgC2njiG->9$-007%AMF-h z5%MeNOrbcX%&b(%CtyXu5GqGAK;zd@M2DOE765R^!&HE>sRfsj_9FH2n_ulfb(Kx8 zwTX!BkirUMwGH#R7p+|CB2BS2fns)9ki5_tphqixU7|gQ1E>uK#So z=%8w<^&(2mO|*wcGjjQjH8>HHV+#zn23t>svnyJ}TGM46_TfXMxTAg@>uBM5RhMcE zE9onI_+~kLDF4j56lk#(!gEJ;l}g?q!@!grRv{e+fud9-L%#zhhtFWp6gHNKbPSAJ zWC{!sCMA}LQ7!OnMz0e<7%Fh3j*4yCA;ADXB$ye*ffQ=U<*CpNWX!jpt}BQrwYB9e zbB^R-bCovfD_3I2>PW~Gh9ly%KU5j1q5IVuP&R^s<`E`W&q9m^ng(%o{B~L{yrzlL zk5&6HQA!Qfm`N zG_*tDq2c_ajih}=tKMKj0}bThdI%JYKph8Z;~1dWbU zo`~+SXlx{Dit}TFcv@cws-ukt{>OBzN17?>B)CQKZEk)@znLu=wvBc_Rw{Scw5wOc zi4jGM9m7K^bu2)%$0wYdQsFknyn)filPEOf-KdnM=*ugr3*o=IB zs#>LZZdFLifo}ku4p8w0(Nx#;Fxz3Cg#+01-Gk z>Eo?i=7f^;Tx-0<;rm=#jY-&S2HO2W8DCan8}{&k zhhdCl@OHx$u`sGmcHKZnplT+gF^Z%J@d}lCDwt3Xw7o!P(-AgO@rY6B%MFRG#k8yI z`UkZw*qA*&q=9aox=Y1!%b#;!9pIB219hZS!pqP# zf$|V4+=dqx!joB~t@Y7l3s!7L6@m|~Dwe$(L13AG`_1}dR*+akii<9`WE>8W`>K>} zOc!vi9=rKi2y#Z}7d}{gQy%T?YHJZE3oX;>r2i-n?(Ae>cW2{QScFd^5j%JJts|mx zOL(N&yIm5E}=ovN2n$=jQ5ySXPeQXuL0h9V#Kn5Hkeu{mmZ3YZNj_Fb%Dcgs+Qs zDyOleI)DByVj%J`EuD-i&*RlVN;*-Olq4xcs@5Lw{Ol{!E`b~^tIv%U3#SZzMd0e( z7fUP-3``}a5{K+tDjuht&(@mNmph&mkg&zBu<$J%cd{_so2#5;w>7h_sI$ArmywaO}gk+C~>{Mxfw2M$`1tWUHXD#czBgI zM5*hCPq8h0>4;i*Bp<3sF!1XIMtCExe5L?Kg)5s-fRe>Svc9O!$aQ-rQeEnf(kHzcr)}8VRb7I~ z6MpSlY>O{ZMV`qS2%3>5Gj$iG13^$a0bx6&C*dmLb6qw4;~JDi(GmcIp3$a|j${tG zbQ04=YF-^hb*ZD#YkStEF47>vtiq#-rzK;T&7Gd&^5OHK^{SM?HF1y)UJbBH|_O&?ACf}|L`N>lst~yrMK2U_g&dM z#x->MM;2jhLnxvbG2S)LVI6I!1$C}>5UYti&(^y3O8<%keJI>%iwn#s|T`?|Zu8wYS z<-(-u$I_+}NhLVq)_pWc)p33y{Y!6})~AR4ahOrmt`V#agN zB$kEHx#7Lnw^pAj4ObZy9S(RgM}*V6(H0o5g35X{f+nQGveD@Ie86w8V&yR>Op|mj zGKe`S57pzI=F_Pwf}=wn=+UF&DMA-RuAEpvBV{lN9G=m3xDJ!3tDOdyWzA9&Ql1VB zlX7BDNx6n$hOrVs8ntd#mQ$vj;S$>e`@4KpUtR4nAUkjUKo8$FReVcOUm|ksE^34+Ob8lLu85y)LA+}vbCC~5i}c8Ga4{x z9YPC;r}(b&X<%1$?%>dch4fI8j!luE2?`=(9hYr87EBCf+XEK0KHfoIfxLWTXfCu) z0EdH%0v14ks3)bGFD|^={Kgh5K%fR9VnrJ#dq5P9wjqavZ#vX0yjHH)C!s z6-}hi4%dyUbP5$Q8(+r5O8MLjAczfM#d@L z-rFm4Ll_ophBr1~Bg;uw>&)>Rv&Zrdh5(_Fd|z;f$p_U>g~MXqN!u2`p^rZt2}IUe!-3w2i7qi59F>BPsEx5u9dpPvnI8>#rZ^)vhZ;8w*Tm+jpka^pAG1L+te$QzgEj!x?Lj zF+;MERl{fKbkdQ=Za5&#qxj(43zUX<8rw`~|5TLii)MFdb?(Sk2)?Ti4+0}v>F z#pYs+w=cNG=?ek+SOTmmc=kErrL=_RxEN|LGm7wz4Vp0pk~lS%kH!`;bIr=gk*YwO zid-RytM#K0cgb!>7;WmCuRGiNUxVkBcPBq_>K-_|!{yGyo7ZWtQbta=^-`koB!1oe z&GEsxWz}!bRA-DOt#-J*O#hGSH^*+q<+p}QjEbsVp{@RwMdDCt#i@YSx30r0f|9m$ zAE`dSm_6Q-;G=t5j9kX)&&G&JF3672(Ksi+d>&B1Kog+_q$aqL5m5nTcnlVhqpj_i zY2c<1A+HEud8KX&?+ei>Ne+-Js1BpGTcj5jr_>7E!EZ%@BEZclQ>vPSGz1*F^+imz zGE#8W7Lq9nk|7VUCo7wz^*&z9dbrjaL#~O7%$oMt)~3+4D$t5(n->{Z(Kf*JtB|F3 z#?G1L&4xGMJkppYukHnYR0q4=%=(^IXqTN?Zc~_-R)nM98KalHn)qsG(&j8zdZ*R) z;==(yM*I+WoIl;WY9JKREdh_giq|%@oiQ8!4*wPGxj5dYZa$(gD6y#;oipEy;$a<_ z*__LCry+Y59g0Bp^Cg5)&Qy&?VZ(A3=}f?H#%ZY2<=Z2&!DHM~LxTY5gCXa2CTLej znBSnXKAI3ou|!vbJ8M2QEK_B^KndtRS+Y1kYyf3z69*uBQk)8 znRJbe&_ah4^?ROIWh07;uw4SvZZjW^tAC?m>S;$n`?|5Ya7AeS6m|RM6?0&bbt@WIO1VIDyvxJQScDc9Z$kE z?gG5oJ4t3CM8K5qbTMoSKq0}8N)>2J4Na&%ptg`sg0U=oayuM35R&q#3mXFlvM9+U z4hjk>fI;!Ut{-{TUSXobA#2E-#}BY&ys_dbgQZtrpKb`x37Co%JF&ByXGiwj3aVUH z#&&Al6IG$Dh4G4ZNjNqYAv))NtFF<39b&wS$e<&c9mRn1uc+?MsiUSG(IkuReBi!)I^LJ$rKR_Z25S zx(DxcH+<=KXT$yte(IIZJRj?`g0kut#1?((6(2eT&VGXC=#esbHp-vxooyd1WQ7O` z(WoKvIxj%yhX>CqbOak!Wj+-cu!pl)N(rW~41x)31p2apd=rvyjRsG!2lB&m&A&aq z{s33-ph`W;GArBImg9%7ZRA}=PIe%0h0umLFH5>RUN*ulcxVBBu@9+m&rGeq|9SEd z%GS2Y%n#WpDBC4JLnMaY@pp}PyE!)Ax9eacAgwN?bLgY>sft$ z^Wmei>xZ{fcUU)$re+Lmp%!KDZ>=6bPkWR4@F&T{i~Zfkv)^prb;s@G_APgq=M(1_ z%bU%i!>X=t{5nZvr!3_3s&R2)89BGi!miHS*Ur0g^kS31hfq}oM)UAR@LISi7Yt^( z>J7!^+J_+7Q>SxjTtEXwL0CQTdY=XmunPbS1}S@z2WQ!5JCGwCe){C_B@G-wmI9Dk zjtw3>Ud@A2OPEZODNz~hQH9L0vhs)49mqcPG z#mHfCN5tq%qHHW6Ufl5Iv95{0wBCga$qt)OY#5V>kNa0#Snl!q30-sIi1V@S)tR5$ zF&B?*z4>VI(%HBU$sa#fyhS0iW=&rki_Oc$Ul& z%thJ)Imi^^=r4ejvF(wp*;WY(KV<~hTF#R+HV{Zr;zo=p6t7=^A!f*pz9b2Tm(PQ6 zSP>gVG_|iGsHrCL^E62tv_?T<;mYRHka8hv?pBC4BL~wR2p?GJK z*ZBaMq*K%070C5{HDnLsyXaTuvKoEgIjwCeq zf!ntzFp4mU_;J$P&mu^%{q{hg#8z;%oMRJ9)0PDp9|jD$Oit#rYba!yEl}HE7B)b#|o9Hh*4gQOyw4=lLUr&9}c<>3r_+ zN!#nIv;Mhn`jD)6Jc-MEp7K@9)-OIfHF5RngVnuh>HSIW7aKQCta){18W+)jHT_~k zR<&34*@Ui$froQxcLv(%R%?S^*q}4I9nd>CshGJyi@<1hU0o9?3gKcp(_G+dO)+KV zn=0YyA~M#9cZP<$NOy<_Bf;Q|$-(0Pi>7xENb3Io#}9}O4I7Y}P;G$V2ro-6npPVk zFz_}&G*N7(f)`5XtyZhO(bNF31h3#FMKo_&qIv1IR!ZLUmfdS*YG%7MYg^lUpYQkV z_x=3-@DJgy*Xz7q&+~jfZaDjZ;chBt2obP)Bx;@xXtt zZA21WN0ESLJDvRX4RE$_Z`Kaz;JWhY*~LI5A}9>~jO~(w*M5N2_O@>8Ms{uq_ptx!S#MCImfW{{wfK9# zPeYIF>)e00evki}o7~X1WAMkhGRe|l(a}ZmN>Alth`wSXIz92Mi+LtHMwa}US^AUw zAK^7U*3MUdlRt&K6)Sw9UpUX?Xwjni`c%D+`NR|Of&oy3j*Cuee z9PDN%fz=0&F)zS3cXC^rqo3)u!xEMR~%hRU>>p`nSQo~Y>Nig7>x zxb&yeeuhWwe1G)gv=aR(2(02m5n^3VVe{!jnXuPIDP5Lu_(xK#^M z(1ag6yTSkAoGlx{mi_BnyaLA%WfP0pJwnpXwDjwc>g_~}^+Ll4^g3sg{1Asv!b0j2 zvc>ko5MrCBHDo5nbGv7+cl*+ERngiuYG-firCoLw;UuOdrI?P+ z-ugRBktI>vr*@WXr}YGkt;B9i8XLUowwIJNujwI%F_^y1No78^kWd8yd>l%X8AyYW zBG7WC2#GN9%s8lOHU$X``8Xyq2^_%=BGk;$vH?T`1dZ1NHps%jzrPq;?=DCK1lAo0 zHHIl{YvdtX?ZB=ZI@zGTK5rQ-6yc37yyxT4yz;!ZFwzlm2q8tjV|#lHhCpT`V#Y1( zBwM)Vy0yCns$i&dLG+`1R5U!>r`|cWt*6;!&PbAI2Paq34@Xa~Y>c`v7{g&(Gu>>{ z(5gxIvF1t?-$G*Q4fk0+?sgxYW>W0iI;}SDrbcr!!QMHHpb_K1Nido)T;n-lCzWKfY!U-sup{EOtMqo@idhLrhL?b??VXLTw8tpA<#KsZ(hO$|ob@%z z&d?5Ylo-3RkA2%z=wA-sRuDxljf2jW7#4!rSrEVJj}fsb4VQy!)hh7wJ?04s1b-j7Rkd1 z!dVII-_^MkGT3??SqGj+M1EQU9u!W(DygT+&<;MxA}Df{m~;EywY{~N#{CEfqGcKy z>^Xg9tVjS(yM#pnsxuXMKIVtQh(#6+nFS5@MUiKVe3V7PU<6wwgKxmm#fAd#JTN-~ zMpp3Vz5}R&WR6{sIeT@At22A&L`9ZxoSZHsyZY&8MK1=%sl|qBjYKRbIa}lV+^E^9 zxswlZauUF%-oMK4Tm!h3DTxwc($6wpD*hmnPjZeB0ZcIdG{wTaQGtgLh?E1t`32yM zf|v5D0uE|dxKt(t-OvD|upnqYKMh32dvO1f?*%rXtm?a?Q0q>Rb}k368;!l8nC$47 zFzF^TqnDcTMx$|P2zIHQ+7x)RPmSqj-*7FaYmjhpS>SzLoyw>P$s(kdWfy7;)dVv~ zF2C~PT#fM*)u*+UO0djr__}R2ry?_8p!N>5%`1MQa9HRA>wE}nmyqJwt%2x?xN~A? z#kl!WFm%al<92CzX<5<&4kCK$d#o{Ix}1sw4r5E#K6;-SMlZ1bk| zoiMzu?LsaNigE*xP9TU67c1cqL;?g23X_g4??9M&3D1A}LrzlU@j*9J~MxmQnKM;v}xxDS5 zgj8T@7sW=g+azrgD%^cI)E*M86Lm|~LC&BQ#WqY2b%n$5`3=OJmr$l|6Q_igCJ@*I zNIOj_oP{i~!ElfqJkZK*1k@}x4x$7QFkX?*neP97ztgq~E^iKmn@T;uzFuw`_aqdT zIEEOqL<7^)_Y&1kT`}agG~W_8UUL)cBsT1U68$oRf@*6(cwSB3wJo9c#x~7_mO)#{ z?g>CE2x%S!I~#IaE*({v4Z>0HbcKf4pgUux9>Sx$jIkaXEy^yLdgGp!PfChvM6;MG z;?!)6V0#Fq*&&7y=~V(o0$_qrfQKUtqI32sWdgPVJT(f(U~!?61~LHU1k&9EMz(SY zR!C_SxfT%+*W-6U)A(eVlah)5SK0!AZ+kr4?z_p~{`*=MgpyTMurM4Fya8sHmV$gf z8BCFz?_~zj$w_v(S<{RBlsT^^(GLd(Ow9{%&g%B6)I)U5R`P6Jcnke?4Fo0UVyCdy zEmKh(kXAAEK$Rm+tPZyPi;rsWR3t{E=hhJpE_YrJV+{`&kikV?_#2x6B`IE$&qu0> zC-4{33P^z>>PWdp$YPcnr&(lf4$dZt-;T0zRa3eeMv+RpR+uth6Rd>cg*>E~19b%o z_Bi{%nLBVw07E{<1TR(?D4t+~y&2$uA%GnEKZlo(jLbKJ%A7INb(tfEt!>oafw%TZ zys**(NC^0ad_GN@>g6%cyOZu2A|GaH6tY=HoXoVCWl9W~s*5a-13ajmxzq)pr@M3g zdr#E&w6X)*$3o3__lEGXGU>{mte*lBJW@2)C%MbCm`#H2bhawQkf+|T0f3?m9_~pH zf>|DzHcCU@5kd3~3l&55oJ?jbnoUnY@%{y{^9`_BBGSPb2X%lX*&}T!DWjxF97sVQ zr2uT@7>#HTapol;fdU9GPsM?QYHRQ*1_wA!CBFOEurkmSSm8vqWCoGDq0xv28+N8( z(ml6~RRRS(yUX|ObxFleiWb-hy|CqylxM?T`j=^9OJjEjkrR06K;EW;|LmPh%1~8PjFS4bi{lLr2q#}3sitZlmLx02ago_IGY-D z06a+rx&1r1GrKDYK+;4JY(VDe!oeErVTIS6c(0IoiPSaxDL}LkLMe& z51q33^noi;#ajewoRbJDMo*6sai|1{QUkRIwh>YRH8iC~2`HVAXb5vgtQ6;upn*LO zFdhIQK#)GRc;$5+P~e0$8qoY|rM>_USbbFg>|OpfWvMOKo6aqY;UM5P5rO44UKpgl zB(Y&o&jnHri1&qi_L%4;RKj8q_hKBuRNxkU&+_~R>cCHOgER$SnI<_Wi@ED_w5;V& z<|hXS9xk}iY!o}+eN->EysP(GsbAR>nwuP5vT{arSoAz$!7JOZ;O_1x2LmbUw9O!v zPm_+|xN?Q@2Pm;ZhjXKPX%buuK?sW&lp;Y{-#0^`Z1jMsoRTsB8x+;SN zIu);y!%+n?Dn{^fHU4HT`mV(NMRdSW-!b`5Ny3Ie1pxqFKcd$RhlLf z#kMZm24YzdueA{&BSLA>j~0T93d$wssF<6+B_U&rOh!qffm0O5$Kq>B45| z=Zoq8_QWjY^Z=!59qS17+(;Nje^4q?K%syb}m-RF$TQiJN^Y+aae= zyaF4*7PiCn72JV^wB-=;h<2hzG)z+(2~DCTh@nIq4)Z$m-#GxzY5+`ZfQK+?qGR}M z4(~b(7Z2?CeDC`!Ug=v?6i#@O8wBCt;gv87Ky^)YMoB^;Eh|kTiHfblT8jqnaJWS} z@ZegDg9-v0dsDF-rd_uw#pwPfvjNK)YB6H>xJ7IMUl?m7olEeZ?uG2TpKmx4YxRxl zIraY8mHo4c{Tpl7rGG>}UcS5Q2&4E2y(Ua<=t?V>koITc^qUC?Z9$TymtPk~;1NN9 zhfJyufS#EKh48IETK9KcyX@5~^$&cxQ)py0*ZnM6P%o%bK}G`qF1ctL0Ud`^>b$9zGql$259B znwaYJ!vmXND?)dcZo@k$ ziJC@-Qe`|8s%|4wU_0DPM{@3|Xm#qpRLzh`mRzR zmB^wMw1mOB(0A1N%EmN|h`7ls`Q$fC54{F+Ui4Q!IyV_yB0actXX?qf;D}MYKYr{! zJ_)2ddIt>#1A{^@piDJ1dO{0SdSk>3O4O&sIx`TlA~SUpxD}<9c$GgK6He zny?M(LM*qX`-q}aKO<4-i>5|97}>WwjiZB+r!46apGs~^hTRSwuAc3SGI%zVNMA2} z^H=hT1BZsj?)7guvNyoD?95)reTwY9y|&kjgW)^&$tF1=4h5_qHf$hBE(&<%D1cW$ z3c<;76~pueJG+D!C*-&%4Bw%l19Z=(9Y`d_P97FXaKJdVvk5R^Bpn$@R3&MFB(YMB zbP?Ljrtxu&Ks%hANHVvY7BfrZlHv)5avd<1CQfGm^VQ1NE-$`z5+G)f#Y!C(TTxbI z+ zt;vVcb$JBr%zWv0XV$MwriYXwtwI+0f*R90NyT|i_d-1rJ!d@!x9(s}f>)6G)UoLs zR%J2R<5q>zr)sYv%=yK|H|4!m(z{h$#qbfI&DhYl{C2w6jTbU%=)=wX1zJj)_kq~S zjIDp){^-r^nVVO$SGNq_@$-w8l$7M$Wlcw_0HLzg)p2&Mpq=vEWkCe>4AkBY|w1puoN!fNTIfS&=b*I_(m;x;E^ z2%?usU?#Sa^?*f%Ol7cD7B!U^AH-*RPFoPLFn~~C19hC7n7BQ6?LQTpu_L1ZgB(;0 z;TWBE*Gl9kK>7W+Z;9gvu$UC_Zbs~QlVh=(5{rE#y;}PVH;sgJ*>_OBh7IZLitE0b zDV6RVxUwSdi5#_Y30<1_$!((i#=h$NnTE=o9CyeUH$>%!Gb_`wl z>vT}Ix8b+HR!(GZ`{aPawq)P8*>`S*zMagHwECpBi!UU^lejr_PfRD9o!7<I zxj|M=e526x)Vb;R{r9nZw^dp*AN|+jnf|SRXDvSUol@LBS990pNtEu&+cdAms_6Bj z>nm&ihsK+X#iHM0i{@Ikgm)?G2KDzY40JK-SdAD%Z>6&Xfha#g>knX|2$=TfGTJ5| zFDIT8pFpnc5ourqrX3W;paY&NP!NbjG*VpQIuP0-CSaJ%8x2W-GM+%sZF5g5$N3S5 z?1_*Lu|PvHv-6;?li`c1iL$r<2lzneB=%8`k+XJATbfuu@MgWe$yw23PCI)<*NHtT zFUOV!=De~GmAIL^ttSI#>h^6E=*oFj)Rz9(G9xLcD)jN2YgZ~!pN1ya1UFlB`=c*E zU+_-F+}&7Goe_G5*e+uR=?`ycsxubUB53un{gR!*2#R_iX-efs(5()FjGZM?to zvSi>7x>Vt~FU~ELL3_*%7>M(=o{a$o*l!yK%54~QNVA?px%l`y4}tpe4_W~U*Z+I13+OPY19fL=7I zxq3@$DcMc{`DC^JLlQ8y9m66IWH!n;!%8e?`H>_`$kiq0(;+0Rk!!fL)Yuo3@KT(L ztxQvF3F-5;SWf-xN1tfR*{OowJ(dv~Ga7dE{nsm!HhAN+Z*meNOCGE*TR%Og#w2RI zQxTq1<2(P_6>xjYS?_&idqNLu`|J0NZ@m?EtL92(M(xiTgX@>8E?55iZFXush}a)3 zOPn*lim7ah(HN&L^rbTNlN{D{^adhAT!1ePZiWKXe!LQHVlyMmvr$aAaXWxWGN{OH z0vIPS$aM@^AevS~R2Cjs3h;S2A9xV%s51egfzNjiP1P}nw~ zk^?Vj&x3dbh|e>UW0Q}gvJ-m=uH+Og+~&Oaab z?5aCVs+XVjE+g^p)ywK-6L-(|pPt)&{LT2>?#olLWi2k*Yu-~gC;IE}9$1BU1T5W& zY0Hi@yFLVjb={&AyIhJ=Gbwn+vITiLh$Bb;L2zj~DY_^uEH4P-&T{bj7u~fXJ3!z~ zoP5BZ%vM@KDuY{yDc#W=nrm=l*wB37ax)rgCIqqye45+wvS3?CgPMJ&_0Qe2K6xBR z=p>MtDK88Jo@?miyn6!=JQuuOxrWp&oGS0`uE>qC73v(h+0jAE?)M7v^9y+1c#mKc z8B%E!;u+cTm3vJXyJ7jYZ*K=o9b8{+q1+Tv#>?n!q#dVsr9PUSEZ*IduUhbT)ROxr z7wBuJ!rwn%t3Q~)pgt^^vBCLVxG%}8qivzJ-??$WwewY)9fufXL-2|+g}&O(aZEAl z;A|Ul4^P|iHQBL~^wodg;h5CGPC_RCgZ;)H1g zWOXeQqr_Y`==wqc|2(nLJefQyRu#q7-Lvl7!7+w@OklEN02_E_GZu2E; z-sZ}g&V4br+)*jbzjQ# zJ?lj0O@3P`MsGqB^>RqN~Fu7k;YMh8ZzRQC#b zBE!lWdy(zB&CYkf%r(Pxjds@e-lmScsoqZe&=)1t&N=!e{edZqsVQO?ArBZOv{;DX z(RROou^eP%L_D?GK?#F|m)dH~6G65OM6n2(3bEbxg}*J*#x}@vf`ee8aJ-@v2?1Hy z$OP}aP7Bt4V0#|O>A3K#Bk<%o)vSjY}vi2NZUaRTL2#>*(#mEnCnZ3ZH_Vi?VgA2UAT-#oB(Ou;|$cD=v0_p!fLePRCU&JO!;TFPR&xF77P)=YFn7c6zY z%kDZlnce4NuP)f`7P>|$PYvp!Q6ejKNw%PMerm+xB!oP0o%`>PpeRu0;-hUPSa&XXK_}g$wZhD{M#;FoxFq{r^J9hM(yQ?U7mF*p z-e29ByZm0dwHab^TdbR7A4SIV7*{E{@aTKU?xes>R z2mZw3;Ib7ENs332fpPD^V&pLC#pSBSBP`PLUiP@wFho=Mu##S-}ixurCW*G9x>@;?ygLD7v-QDcI33g5j{ z051X|uxf)rjJEOY7C|X?yf!c^q#`O1CRVnAP#M9{2(ym{J=ldD!RigLYhyxUYqs9< z$MKw~fEW}~xd;sgH;4cS1>*6Lzy5RLc4k`xkO!$0{8&VN-Xv}c;&oTlJ~A3_dS2rk=Okyw4 zBzoC_`BFxOAwewX6TK5n7GeT13kTp+j4PdEAoEccA;6bc2xua$3dO+LxLPSwrDz)> z2Oe}*K+ujhhr;CeO`#S${sxX7UuKRV$Ai{cz~v}w=c!Bt(+AF;79fD1h%aca0N8RM z!FJ$_)oUN_F=7#4qw{2lS-1>TQy4ixp0bGtDH5UCXf-IDQfs=>bzL9&@xR@C)-SYw zs({3@RC!Ud9rT1$~LNC@{ zEIaa|D}?qWQPfXg$b9tUOwgn(~@qS&Q&`Oe9q_RxtTA3_=U}W+(p)Q{8k}p8P)yqb=&x1+LpX?t3=!SGmwlERteNIJaLp%jTjPnf%G#SXt*C`S0@Im%7sbd@{Rg zn5k3L^oe^f?Vqc8TJmmEd?(|;xxKU3bZ;wWTctC%DXfn};?fq9U2kuFQ(c9xKOVkk zeOwY_jk&!o`^JLr>g}^Fo5R1$;4ik_xBjrG3p>xC_Vx5{T|0yQp$*g)Nf%rY zTIEDxaHYL5goq;Z-Q#`W_B2pf7J7oBanab&(5VeOT$SApc`6o8Kk6I?%WH!HwmD)~ zJ>H<{ZHL03xO{HTUGovEU6L_vlBogZ(!?Y^p%?=z6$T+o?1^Mo`?jbQ`BbVGB#-ZNApp%d+;E1@HH{iO26RoSVy?J9_A=hJVnPIvS=6^G6dfEgBBKc(>Wo zvcG&tvGxA5n{y{Ur!X~&Jy(7Dzmx76_%m+sxAgauS$i1+aoKC%WMrllGB!*9kp2mx z&7u?t&frQ8x!XJIx*9j3L)cNusP^r)Y(ey$(!lD@QrGL8%0LE_r_@Y< zmpzD_56H0M1$lx)V3Z9pJ`jp+nx*-B;L#MA%~`QfT@AM*q!d8UVu6zIrrHsW&Lc() zQ==$90Ne_u3k(7!{DOC$(jkHiyfTs;Iv+wr@}U@Rf`jG+l^c`q3FHBos06Y+k&d!y zfhh}xJdlzc!{sS~b_zGl>3R^kv6Pt?#Pn$++7la#S)JSj6tSF=-&n}wAU4iw5!&{^ z_E-!NUWy`Yp;v{*Ly645zdk;ByJ5&!d2u7gy``u-(-i1z>s~m=*eacD9wu>5g3H}o z!NGD32Ww_NO;5kq?|tv-KE_<(vk=DB9PYqD!?jPN(#wwbAI)f9i+phH}m?)79uUtEg^1#mCW~dtCrSpp8P2Nv(%@brPuy9{m=DXi)AhTU_tTky%~O7 znwuQ@`*MG!G^WT>GujzD*>*{^oMf|C=P|kEf4Y=NDVB#Hgq)p-ZY@4_Z#1lIp2=NF+Pql4oAuw4;H58Q3w`cu) zxl|r#s9qTR*S3#CLAQ8O9>lO!aHR5|4{xqmhRQ+yC9gY?xhzi$3Gpp1 z5O(dYsNoKZ4|*@pbYVkU4qwZ8qwsQzFuR>~Y-;je&7Hc`(^d3)P3NncuKuq?|AhP= zwkPZItp|Gpr(Xk54K80LteU#={U^KsvunKQ*nd60{yFoP-Mgl?`4pY?eRQezq2U#G z<yhrLt2zl568v3?Qm`9wx)8lh|thm zVmSzF%+EN3I>Ml0iNq3$5(V1(naT#DMi!QH zp6O~p1_n8&2db+n7V+jQ?3=qW{gvHH=+J5z!QVLI<#FPcPXV$zlqa=gglQY&7!CNh9I!oFTGE>|aGkG-o>{p;vtEIl=;M$$P zoL8snSNFC4;W6+iAs-Oka5ze~Uw?EhyJ{)>#hYJWWWK0gOg=3cn_%pC`E23HyZY}8 zE32oDKZ)~yJ02M)>&Rb!yuZWvVm?fEprg-4HZ-|kY$1(3QrVLSlTP5hJa8kWM4gkZ z(#6h>4#u!4qr#Xbt1TEUP$WR&0EY|UyJO;nsl`G?#WMh~KT1Hh0w}zgz>!SbK>5v1 zDS>r_mdkrHF|MW5>tod_T)r}rpewY*dZ7s5vH0ZXirv5RAM|`miogkO6-6WF8)>Om z6x-}sypWQwU!AJ$EB3=s^>;4I?il3@ky!1(y$8OkCa+&#Subaw|Eemy>v+zSzxHhV zw67|3_2u5ajJJs|rE__~@c6LPX|sLbo~0kD{xkXW;xnJuoc{D9sp!c2+EIPhPor(8 z-kjXK9FET#lx0cbsGvTcx&X}XF;t^@ z1wIHnA#szK8u}`g%mj;OJl_U7gh#NkPK51IC#bkwXBapz$FqJQAreq@s~eRWkDChs z>^RV3&k0Q+!}5~K$24FJ5g3>@sf=gBi`6wuCfHnkd2$Ng5ZqoBc$4n!ItJUYolcY& zDaXTAPqup!Q?qhzg~y@Hm$uy8+RIq5m+srU1q(w)nrOvU2loBX;X5ne2b~G8{pEPh z-J?&Bo_oB<@mkH7qTMgo%e4X-dQqL)-`GF>Rp+MBGgZ6)CtUj7XUFO#w@!ZMI+{10 z>{a`RPiNNJPQ~t;+wO+6ArUew;70Atfb{&82`Vq}A2%u#s(;^+TzNVz3XhAtTgc8k5LsNT4B= z)A}4u0+bC#39MpDJJTx4;nPSfEPt#3C6*9zDjvcP|8diw$9^1hFlSjb6uJhIFXXBd zJ!LMFE!~;?MzfJ`%J?KI_KV<07ZIi#am`M}7jJKMsG*q}(T!RGB(n_>7S&je8Fk?I7LOE~U@ zl_C*+emcva5s>tFIq;;B+`6q z@2d>Xs?i|aF%LcI(Bs|_7I413pH}9*_sppaD~WzvA5Dbrwb`(9u0FIYQF7zCpX#Aw z_&%^m?0D$q|NCv;+^(;?Vq2RP68}XnVIbOM(cX0yAPE!)sO$&97)~+cS<2yADNHE% zPCQ)SxL9jVaGkh*fvB79<0FS)npQUGK?Y#dc_Opn@-wlPcyFqOu+g*?Y z@G)0}-K-dI3$w3OaUe|S=d3rGu<~+%nAvDfMVN|&|E@g33)3*GDLWEiUMtI5JaB0- zk!RR{z_LWzzzA^5-oK` zMIdHE?(T}mD+PEoAx9H0P`jdWt}3(Ox*lfZ87~+mH42IdsWx7q><|h6`~Lu&u~-Sa z0dFnRAFwMrQDoa})E;<{0(URcXM7S`mnrYQ7WcJv=Vt!V5|WTxbc>zl!!~HvgR5#VX{o|_e>&HlJyzk6*GWV+%tw`KVgw^(q?2Gm zExzzULW=%Mv8@tKP~+lZ51mO`FqekS6G+^X^iCC80A{C576D;+@iYzqjfZeuUL;uQ zlPXhShIWWjC3+wOjr9=i7mvRgu#C~!%8eLKi*=a8fzSBSku+0!c}j^N_?X>z-Bv>` z_k`yxy{hpjVKFfxv4uhN;qxwh5giRi4hgqcZ(SyZbf%@Gq615jV)MoAlvEG@P-8`K z_tlo(iRcT1lk7o;!?HYdLc3O$UD>^`(J-}~o)y|TejqL9W_a9%i+o@hr4G+^izhy%T048R_gDCe=u4$MJ$m;_V;?ls+i0(dgG zR+q$aA_RNtw*y1Ww?>fNLn^t65IyMQPCzm7rFgUr=3vZC|E2~#U@AENeX$0^ZQ}=R z6}b5Z1fRq@Ny~F^r@|r>fUjR)Oq3x~5RWe@#Q6BOI`XBi_TljvZ(WQSo7!o(l7 zos+dA7SG$fhxOg9%?Tz080%SQj18#^OOjJ+5-t)RO*Fd2wr$5}5vC3C2^e_;*zsI< zp~ufg$>n%>0}52+Q4&Z@2&7Y(+>lkB_aITqnCK3S=M|%%4W?0IWVOgF7zG=jB5JTJ zBtDtPMzEF2$49Fg;}?@*?QA4SD}Hus*a`xn&Dz#pJIS=d8Cz4s&pgnZrP$J<7Nvd? zIL&rTdKH$in3$cKQTdLWFBcx(=?Kh*qw`ryGcWfBdmCFy`6I7jg>`9P7*#h5KxdwR7IMZPOmAqVir& zeNkLXsVOn#HFD7HXFGAcw+|quo=+w&@KEktKQ$ zL$_dudrLzJZ6P7}97REy(mB@!zp@Zugc30>50XgKV_lSbdm>C=4XmIrH{kFtJ`R*^ zk z{ismaaaYFIThGc)@AW0sUaYw=cP4uSoySelAGyWI#2As`xu*_OM^&cKgDaiQQ+v_d zg~n#hR7KMEtTc94daR+XV0!R;z=UZ~v;ueY!Ia8r0ur?c+sofx-PxY1wiTyk&r8R! zafR~mvItSk49q(R?pP2!YO@u9bvj*&0Ye%BS-AW!0x8P&iPEjn&)Lm8%X~!VQuTo# zH*cr|?Sr75Div%QG|U}j7DTCJI)TBX0O&9SAk!&!^5h5K4EFMzgdAs5^Eon&=O%tg zUC;Fkd$Ew*gn1D5+pD2pCRQh3Pp(Zq-S~QKX86_ArS)qQYcq=Unt(4BJ}VsPr>)k0 zx~C<9JgaxlzPt5O_KSg=!H+KchN6Y&4=^hjgyt6Z$h@~gKNVd&UNRU04C);Il|Z^T zRGQLU*loR*2)^vdUHj|`1|^ITU%)dZiqup>g~(3M{XOR_CEF~b%}+;_e|4vZVcY8 zgy3+_V5CuFAi?!I00X5C4W)D_8_W*Cv9*`%_^^+Y7nkByvlynhTy)=@lH$*&m+^B- zUd)Ciy_%Twe>w4#Ha#)t*YRP{zkk@bnO#>D9rb_r%*`Eoxps9|+T~lT6;Jja*>_@1 z=Y%#SYZFgx9r*3H0q%g+tO$72!0!&R8?6f-}t3aOHMUg}9`+gE&rg3vqf3WPs;o4oeb) z5gUdtIdI81)j&qU+Pyue;i$sdSjq`JlE5d%`#4M+b(N_bsWjVo9wgDsbUIX@H@Yu# zG(x-s2>}9Ne7ZwRX@QRtBu0$!%sGwR8(_XSCvOarwYXs|aio8Js&`aDn^Tf=| zUWNN$WrktSFsGiQ-L1axdi=8A`A>sBjKIEJIhuJsWXs#fm;Sh$k^b)8gSTTpeSGA* z!SC`KZ84s_sm#SwlBH+2t1v57d#dxpBQ~jVF9X6O0RPO+<)&RL#$n!yc5_8`MaTxV zPG?*16Z%}| zQbDw;JG!I3AWO&sX@t3kiM(?z3YV0~?COgYQ7aB4_6X2m*O)ab=(l9@9h__++I%jp zb?N7jqR*LTBjXQZD#^!8oM ztK+1eoy3*FvF-57;wm@b#41NsZ{*(#0#vyds8Z61@3RPy3BMK92_ z?MNpYivsT^m}&@=_F`)23{GW?s!WdH@T;*k!NuhEGR6m~X*f1UHKBu3to%BQFg_X3 zjzmRUp-81ndyeYU264i<7CD0gFlTwLGtMW^4VnV7;{Z`s9_Umcxu6|^e4Mek#0pk2 zFFBL)3*8u1yg@i&(friQ^xLbl4%#vL#LJ<#G{j`jt~cl29DQ>p)^F7xq;sz-`p@n= z^F{cXs6XER{7=~N*?*F!0RVu9cGRwTX0I&Yt~&G4u}>TZCPu8mg9SZ?F8P&Xzm#EX zf2r}?Z5dvY()Jw)ne+~EsG`}P@aKryvV{U|6&U$7^(f65O(2P89mlRW2UqeY3oADB z1~O6VQox0pupxLh)jc&bsU_9d8LmH&>$^UGkA%h>DM)8AusM7|P>_Tp+Ha#wIdQsU zwz#5U)#wc@*CAUpfRAV+vLFaf9XB$s)QPGraql65(Pj>%0GhxS1_AC3@@9iU1v`HJ zbcItDB0lM*B9n8 zX0HCS`qTZjwf>pQ$G3mi^zW}!08CL!x{FBz#zx;g9V(j3=Z|5totVgd1 z$B(%_{d7-w#z(o6HJJIy>=0_fQ1wO4B8pO8>9kich?I99@D8C+R0P1bCfmNNVrpOZ z&cacCj)GS`GU6bx-@3DmyI)JSsfFUQb zU{HOX%yB=ZPeP?Zkho}?IeKV^=Tt)^2osupkU87j?O@8tNO*o4AE|VNH-HWuypt`0 z<)Et+8mfWYmN&mm&v<(VVT8<1;@7dcU07>(W@={+_g<=Vr6t4guz2QVl>47`J9A`r zr~cllI2nBSR!&B4f7AD0b@cDOd-)&9cX=27-4FndYja=Tx_InJMzPoXV?Vv$ezR)l zk05Z~v1jLCM%kJ0@Yv;*Ysc2MDt4!aCD#JtMo5qvS#%CeTJ9B^ggzxq0}&8MkU$xvq|V1U%xNY`O5&Mqry5Gh z_adDggI`jMV3>AT690{T6u1>|CJus# zcgBG&2oCf6cb~-=`5e%0QoI$|5e$Oo3-l6@aSXkvDK0w@aOBCO0Lxuk)5a(1wR^Vu z4ZS@5rT3%Dw4+B4zk2)o+TVBo(>Zs?(c%Bw2>@w}au3HSPQ@Lo&-m)}_}p;u>B^@b z=Rfs+lDzHKo?o-Uv$0ZQ&FLAi4z9OuO?16@+dB=jtn>0n_9f*Smk0A3LyRvjw00W| ztM==oOkg)>2-E-eDGr!uB7K7`RqdQ)27biqjIUyCYJ_ zgYiTS%_av=Ce&f%VnPAbp|PE2wsTLUn2jtXngS$Y5GE$&m5B%Pi#k0uzd;Eg!Rf>4 zhU-tkx+Yf@?!$pMzYUlZW42N!OYm&*oPP0}Cw|4n49%#ukW=$)?&M+LUuD;}NuLyb zRJ7$;S4R4_>TjjzIX~Tbdj8A%ImZuuFFcNC{=dBdpdmg-&Lxig^6QmT-+#DaD$c*^ z%$bZ`Rr|cZU9k>yUz4W$%p^+^zmc~Zj#Skv{M*QL3~q$PJ8Nug!ZN6wcyL1+70jSX zwL?(+{!C(posF@=kNtuuEvVQV-yol>#br8)J(liZNaq5b0>HJ3N{ zY)m%xZ`=9)mzrIRQ|s1Wt?$?8cF#uEB_%V;gqyuaQMFg*qA#M0sW(iOp~fZYkKTg9 ziF}Sk-#Qcw2eQVdua6Y6J-ZZ?yrhaYx_(Kqqr_WAnD508=r+-MDRzo-~zALgHK92!Z5T-;!s;HJtMBaKBGC)=o`?U+j!?Yx2rG zI@q^zKBVrg&++-$)!zPm%gWTV?|m~)2Q1x^zM1n}O;q?H6)ruM&#P$l`%+tLz%2RT5aSOg zB$Shma(osM@e0PLRI*`CT_~77gf#~KSnF8BAyZTI{g!S>({`GI0cQI)VBFmgEbDs@ zCU&cGp+w_Iubn_e1r-XBbPpsV5vs=Nys)Cqi5vM$8St;7ya+r0kh{#r(8y|}6%QwS z=AmsI^1pCd7_XBvLGBvz$7i4W>IP*u;~X7`)j~HewTU+iZ4&r;!&kp38aSMgGd|~B z6&2^-e`2NUe~!L=|I7WQE7`4+?`X$A^u8*&{QBw7EC1>K^uEWnjNYyj%>UgFbm$)| zE33~|u6_CW=bu_{otzwAPY&N4y7%O+<(gaDd~OA8kqnX-4kmgZ3|_AeHcDnAJ#}^L zg{&WwQ~aepo@n`?o(JcgGq`rbEgWxlX=G=CJwCgS-y3x<9kYX5XcC9Ei|8o#BwKCp z=4?KY_|3Wy8_zI6Vw!E7Yoc5@qsAVG`1}%iPAu*AmczO-gVpXLZgFiMFESg z$E$)o6I$`v;>to(Bgac8!h@b()bCHg-Iz{ECEFDu#q8kp=o{XiwhrVq&jot$#6$1S z0JqDa_v%tlXxy8l-PfkReZBI1Nd2SKPY<8@?)J8WD_8do_RlNc?)_;B{P5?!O`bvj zyCLwp>|6W(^ZDnWjIR9l&HMLPj_h9f(*KBY1>~gtFV^eo68*})Vchm}Ot|Z#e{kg$ zsV06*;orHWa`rH8CUK9*kod~r6Xe1lvH)BNvLH2-U5(t#8T95jk#T!nByL;h+g(+} zd<`8!OXWaxb%8{zqo-pUqKuGY=7EiyL_&l`gShh<;wS8VITUwUprg*_cvd~`Y9N%zd!JBb@H>8+`s(i z?w|OAvhDxv2i(E`$>+OHPCQ#&A9(-g`=5_Z?&kj4l`v7YVQ%Z&8yWU`d<&_vbeA2esuS>A*MuEp#EpCkoAW3G&c~9r4AZ>>M%&V06QSlpk2J>Y#NQ`*>03`9pf(o1ZcOAJrnX`EO*dOQj{Jz+7-ST| zYSp9HWLJl3a6@38m6$iT{674@9G!by(r5qwFYqJ#h~xm#fDQvhhp0_JTiMn=90SyD zFf=i1q=1K7%MRPx=>|dr!Ul*Z$_)q&&01e0h2;B#Hq`+B`!@8|3Jr&>RqnwYr!!Lv)N+ILK$jNK^+`_|^(nFsO)}r(oCntP-u~zB=OY%ngqI4Rqo6Js@p z!+;!+vm6c`$2W2-8zVEzmwzsO`{d~7$2T4Ny7y-D*p0?52M*qOhw<%|i6ea%-+gb@ zwI$kPt@B&HfBE!Fx({`;^ZzG%r}^w--jl~aLJ18WC9{rdOZPhQ#fd@pnS`neG}o3qFl7>gY1Wj1ux^puKPS8k4OXk>}9 z%O{mNCE|9l^<3tNz=M;XnrmmECJ28s#_8dwzD41Inem*#OTt)nJIL<+R-C-CWGxPQ zJa%_rcD=3#LF!ekO)j_N%_PJPLO2e?fET59YrTMBBDp3#xW>@Bbk4U&jous{EBI6_ zE9UXr@7FYFKFej)giKA$1f1V$qLr_ZA5@*Mq2@e%egdL$iNl9Zw;s(nFt({mcBbRi zj$iH^QRKb$(>GNw{&DE<*RK`*dTTa%E~kIThxvage|P?ywKYFX?J9O1q9rDfS{T1; z?{^6!pSPxpJ|J!1^U1r3Q}6Hjx$na9-Lr>w-}|{^Y4Sh!sdrsldg}7g%RRrok^4zj z^{L#QyUs5#o;|hT@fk+@sYFfx=@okuQ>S(^iaIB~?oQObUJxMdq7JtCt2qUqR?8a8 zKINk7h0Ofx+RNqUUEhM+_((Aa?RhG2kMN4V?M8=BGm@8%VsfmzIN=bxUOB9E@npUj zp3KnLTdn(74!G=?^mIQ0?mSSM)3BykP#fuG>!P!2NhSg zhnu7Y=lbWq&f8I!d%W!49;kvaCqBu&lH2wA>D<}I-zt8+^Oq$rmT&BPt#$fp@qv_y zx8D5t;&=Pc&z^6b%6XHScPx2L&i1PN?GFUmeTR;`@Q;fx)Lq){bemV+&&y5z`R65X zzrTLdp%={^&k+v&`_P+*zPQ%$N!#B)IyxWzA!ER2s(=FFl1??V-HJx_T``BP?R{%{@l&ar)iWMsh3k^XmBSV1v41Y?uo0py{FPUURl=m@f+9H zy!gwVjW@oY`a?J~xTo*P_#gd0?7UdE=-?yfnv!!bD*LzX$^5)!%Zl-;nwCqiA6l6{ zS;-I%{&20k>X~OhY@NC~cJ28ytsfnL){n22zMQ{mur_cl?M%zBV;@cJ?il2^?B2Bj zY3LVL7jH9X#0OkK=c$F%0Zk?KT*+bJpx#%9tZiUnQL1fWE+!LAA9y%Ad}o$;u%;9z z$mO;}z!P;Yn|i;mcSf5+euR{w0oyL!Fe``dq(f|*8=7UIEvA;HO^2Egyn^cBdXEc< zEfZYior~{HnE;XO65~iFYg*TdDTRBQ6Q0O%xiYVbO21e+zqU!bB1L&KHy6%rH5JU1 z?cbQPbxXmPBk%vQv**>*8@qbGi+gp^!wZjXEw6^V^uuemn%3`paO3jM(*u|5E(OZF z54CT5bLDs3Pmg}P^Wne;P2cRxn)teI{_SHY2J%;)dtp=Om9f)-x*y*7`;Whr9A9)k zaJK1H2tUtt-P-!a@|MrW4r(I046~yx;JQ?PtK_Popg`T3tYQF7Y*i7K!{=(Xy}K?f zzQ3qSe>5{#?nKZf$D^?eQQ0Ye`A0aE$nv^li=e0olemN~-lRitWvOiZ7EV(B$wnS4jvmxawc zpQj%Y)`3w`%GdsrTT%-ZyR@8oS;!^Tv|mnLYnW`(w|Btik0U_kDHuize-c z)9n)(@1OErDD3JfJt-=m+eaPzLco%%@AsVKS(6s=41*pm-y+tSIn6%o>csZHb%#S0 zo)Inev+Q6%jh;2a?L-CfDHbOW-`1U|EyBl0M%X^gfwPbZO4PTlzM9HTuI@k??Vdt2 zE4Fr+Xp4Aoj>F%-y=eV*mxAbrPNALY}qBlEd>TjQ3`1ap_|Ka!s=x54H>_6Ln zXMT^&<=Nb2-s38KZgqyp^yM8x;7Hc{+pf&)+3*(g^5yRj{5*T5@$&K`tJ}7ITeDwZ zvnZ-Nnz3WU$nUfPRSOP&x2&UIL+t?S;5t;k?Et%dhuG1jmApK zgN@Os7Z)5Br%+N@1VIr!F`}ai_cP$E7-B&Q*<4JxtiFPhx+pLZuBb4pIs|A-pdQ`4 zPKmJH|NhIe)ngr=^M<7 z+8TP{w)w$>>T8iE&k*&CZv)?~y3G8x`cl6L8nIShOM1Y1=$lXO{h~xnf|~$Rs-ZN7E}z*?@n#ukSr#euyCO$Z`6}j-PeT5LPad<5LE;DoH$&_*bYNs z0j3;xuDLF?Q z6H5nbmKAcRb&u;pCp*ZAES|6b(E+z38kv45J9KBc{p6OUWev^kxh_KgKOYq5wmc`h zdMZPBuJMK12lJi1cTCp=!y9b(`%3fEetID?dB27K>l?jYJEN*W|K5Dj?5ag8%OhW{ z^ld$wckJirl^Ue>R!`PC;=!Fsst!p{F`+^eiYo0V8^9z}4PePSr)00aLDYS<~%5Nc#AxGv{Ho$q$ zo4LzZKHAbUa6I~T#`1g7hg%B1dw=7?1p^<7*1mJ4cH;s;j}uNT?!rf5b+j3sz(L@{ol8QI zL{zMpP7HpaH{W>stN879PGVk7Fpg0P(;P->LAIjgaR2x z-Bxm;@I^{edmEo2iPMmL>XWfe{7F}3Z3_l`Ajrj(x})3*I+=q%?%*^)GMh3AW4M;X zD>tOR(6Y&(fm3TB?AHnEV^N<1afl0`C>zU%2l*fW15bbO#`Q{kqA0I_8Vgw=`YVTF z$a%AQ;Ni71s}Fp6^86n=-#<>f({pd|f%X-RbYH?^nYPb#fk9F@YtkwkD~~Q~yROK+ zcx1I-*;sL>re;SgV^eeKd~Szu{kq}@tt+FgP(U7nR`!Lt3UkFiXeVwyNyq^rkZ$T0sK4Z8URF(&o8ab zdX0V?R(x4W4igTuLL@=RRucH<J4Ii&9nu4ArW_CUpI%2?{Fl4n8h z8$ z0}AivWHu>&iH%cm6rSp_Q*{H2a+Y@z`MvqR{`idxC2Z1+Ys$bZ8Na(@8NTF9fIP_8 z>r@1cV{o;EU4%gQ!NLl*PS@ULmeuA(ZU_n_?MXT1L*06vKFQgUlrODMlBZ7Xh(@A; zT@G%@-O{fsrP4;ps2W=DZ1QlFXChh1mP#^k>XguwYY8P-hXBpaA_qDRF*vF!1tcLp zD3m00SuM}J^|zmqV@NEs14bmob3HwZ>Nq4oiZ9#`U-wrRum1Dxm%D%X{jXd8dhp)| z{wn?ZpZ^0_{y6{AhNque`O~Y*{?dHw^V|P;oR2;I7A?-WN9gl=> zEi>o(HU>z26SAHqv}?IhI3Aad|FosIWXIj}&CRKu*HSZ=rNMaE&b@~^mNe8fwX|xF zI%(Ah(Y@3-5&7}1JCe*v59iZ#(HbK=GSj;yPj}00Dyh(yc9ui~Fli&PAk<4fCiWH~ zZbNUM&xq|4=ju=dambmd)#1^>kR%+9rUCFRpekcjV!us8?KU7d%t5yh*fSs^`r(Du z71WTTKER}k1f`>_-SSQjOKwREtS|WP;e)H+{rK;W|2}>7ySwkqKmW^r|9b7McmL9P z_12|2Cy=*6L5W?v;0K3Eq?S@|_L63iEE7T+BPiJ9DsYO2!g#ZTWO1kr<+yEv$N1 zN0nByP-LXirikpi;$oFXH|LX^ic&CkNJETZv9|tUl{W_0P%jdycmNYP;$VQ94#HKi z6ZD1{xUn_N>evIy;j~UID?13$GL_^ZT@m-+A3ohK2bjJOk{|q~kI=MkUWJN2(tOx_ zrejs*w*NjC{$~8&kN12sG4{)gYnNWmfANnue%tiU@%5`;KhjbBbH}seul(GxsS47? z{xJI>V!iiLB%WJrK5^;Iq0B41f!)z5Lx(8dI4VET&e?z`1wJ)AAUkwHzC&Cam9@7^ zH>Mra?8`mWyQ4nYF*$4-SJ#t57KUYA+OP|<%Z{&GQ6ddb5Tr7ezs{Ll(ldTN@b)ZLooa`9!= zdM=|;<4n|?wT3*+SG#qY#0t|>vN=I~amdBa4 zg2xu}2;Ya$dQ@qy-MQSj9?jl7;E9n3>2}N_4i$J&NWd#4r-BOdFpG#~b5D?QF?4%c z{Z?lR&f=`r;V_Z}=VKkgzUn+umRH&8j1N&m^?ZU1j3s#){)TK}R}% zYju0)7lbXI?y{ljaDl?CO7$%;hcKg&b2ZaJ8b;bZQIpRcv>z+iG%qvbiSrv_5aSp; z71M$vP*uTAa|8C_bTl+0q9k#Mo+FiTEHxkNHcX~l`BOx)lWc2-o?wTu9hJM0pcC){ z7|5oRyeL74Vf_LQjwWzw_(c}-FrHjrjDcrfzWsB#e*5r>csiU$YOI|AK+#@=nQrLD z#U1pARVV&FI4io+^icSl;GN7D6JGzng!B4WYfkQ1(|YE>+y8xk^_Q!5&ZLb+%OxEZ z29elbW~OyJN=6&9@!04j0Sn|u$p*8&)`2gkFLm&ECG*Di7}ZV@QJx>FtJB;b z3X#RMDBX^@E-0bvGge3%W9c5L<9%b%D3@8=P^F}CD|s>yuj(Bsg||Q>9)baY?10Cv z8G;KG4qbVHg9jjWvmz@p0F_1-E>WHhR)2Ki{$VAA7waQhnNN^dMuU9kE0M$!cmL>| zvU5jmN8HDkobw%%zg4Y1`MUX!H{M+N<{KXme*ODb_b#_zI-h&{TJss_8Sj}~zAbJx zuSr1Ls5iQ7HZPY1$vbqXNt2vg!L?;z!Z>YemQRcqibQO&ZOFw?FEhGvWnbzj5zWMD zB_-EaG+iI7$^mxAZf-)Q#4Hl~koP1(OHL--Wt-!m>@m#h z=1O@LWH81x+wdwtw@7gQ+@vo!u!V~Vh+cNV)5retdwX4Pwq^S49HNX>(m=J)cLg1g z^~0+nH_$aUINj)~>RS7+-x9CBx8b=B3lA@PIPxK>Z>RA1J1;c8uGFTAW$O2pf9^feJ3ZCx%$M4azhn3S10NC&3LNIwM>Ev|(OhdIB5fm{@ z2Sr=wrdoH-Uk<*1=#z$xrJq1ac;B|?HocM$%fHy|*E%+t>b@T{Rly)24U06u4jnKn@4PP$j!Y#lG^!L zRNCj3F=oikb4_9?+1VY%ZzXV&baRY$>t=OtMN&4L)gOz6P-1Acph=go$;yTpxOp(7 zTyrJlSb#L&IRk)V6&NmL6F)gTcAwp{h50#Z&>Ld#adg1+SGV{DEp9^$1Z<~vvNEy` z99;Dm$=WYh?f7A0dg7y}^B300?`+Dua~%EK?7_8JE3$6QzQ}c5^2&-9mGq)33wkiZ zglzgGgg#3m+IGa#&vt6tZpYDwl|$+lSYQvxD`V37N_j!DlcJR}AV(=$V?u#1LzHTr z?aC%wbUiYZMkwhC_(*n5b&m_@@IXE`eBDoQqD3gNivwiV81e+!LgYbS2@&U;DON&3 znRsC!K zymbAS9Y4I6zwk&x_p9lx@!Q{9J(%0>T!ziu8KQd!waQARzeifRx*Xo^2be!>eAXq5J2L= z*}48&w0nsdFlkh{t>d{6zJd_|RL&r7=^-nQ0-3xPZ;KL5%A&ET!88vIz-N?_Le{+V z?7^v2g?IbyA&isHBQlUcvQ952MJRqKzHu7)zD6SB^_+2aZeh{v8;_cIQ4CMQ>2k%9 zPwJ>}0*K`WRmUd1zxel9$S9z%wvqKuv-NTYV8cvEZ)_tkp*^-}hC7Z%@$p z5^g*%$brnQP>V1U^0h#DOdF0()=cz!OaXnRA}}`7kyiZymd9oOM7>2T|P08_0w#^p|6`0Durmu*3);P4}1LU%BHQ~rS-2@ zdbl==PYJl7zJlxZs8R!{+DYC=LpHdE9JrQvNE8QEyM3dyQW)ym9|KV>;?KI+iR!&V zSs`Caci{4f(B@w))n=7GXn+#zil^P|3fWbD-a8&02n} zvh-o&?H|AC_+~*xBQ;uI{_FVpFLvrmawm=+xc=M=@_|~qT}f7w#VPb=n0jwTF-;3Z zTJErw_CBGhg>MK_N$Qr`5=_do;>S4jC~)zBPtxU;aCO}@E!QEZvdG`g`9PHpX)4&I z$<{z;48Q|AG}j4TWEh8;%K?BF6jkdZP>|N36*$n4jYETA^^waDBudVPMyd? zmAGL!iNeX8o~vwB5ca0$ka5fPIgf6fG}nLL;GUbCK09;z^TS#F5AQ!}j6}fLo@+}4 zQNc{^_Sp~C?hJev8<2U-W;{=!sN^M4l@?&Z;p<73*rLOn8f&|kFcBo;?Q`8qDc1uu zUXUnX(I&-NxpP!AC>?69C?+e{Y4)aM$B1pGkRZ`BJZORQPAQ#hxlO|T6lA(|1Sz5I z&kT8#$pUKf1ukTS!6By{zMm3HQ5ZP+m~NeRA#)IBbefd$jMF#ww!#P(m8zPbY7_a(>D+ynqOKOEN@((cgg z=k?oLvKgw~rt2vnAEHDe`o7?h-CEMnXYRYQ$Xv37@sYiXqW_|~YMmawihNB^`%}3F zqY)!V;j`O}1Eo%p=y{#`#9}4>0!Jm}K(j}8wW*2djqebWZUtacY%mFj$HFiTSk@#L z!jyQoAtX<*$s96Yu1vpqE3sK%=YjM&6nN-V0gk1Cvq~5{A==!GrN%+)p+AP+fLI{B ztpX6&%kMnS3dwF?n zt>D)24FThL5$8m2Eq_biRJ6#Ju#-77Z0&(csU-<+Tq9yD5ILx+H~9 z4}gOk?n)?RptxMY0nj|zcj3apdTf6rLtL$f+&j1}1%cX7lvic1g%QzztDV@}n>x7(g>L4W>VI2poI!b~VJX ztSuUnfde3iM&ilPd%J=(rwB4aNhVOQCc_6^3MT^-B|TnJEH;c;`YcoyB^4*L*!dZc zUwC)B4c1^j7w?Ip#bTBTk~K8lib@`qGq6q;j2_vc50cq_eU#zPhAf(XJByE2HUtkt zx|4&`*BfXKCaK!n3EUDHpJ((`V0Vz?R&0 zf{~U@Ni!RL#e;2buve68^|SHgma>OJ7Sx+Dy8zwo2_!?_^SC4&!PsQ=SXzS(?nuzR zq?=Y@0$>XVtvI;_ZIW1gh=2*YozW8E{=}6*6_YQs060QAlI9DeP=H6Epvi?>6)OpW zpuSTYBb4dNi>|=orHe#fWp%T=Nmwf@ zP*0DFgbWskkFxr$#?c^4?Z-D?kmC@@MIVQSp0g%hqjF}%GLzIEt5J$q;z!t2D6!Z9 z9R2}I_&$`fYrFwLfjs9bY>4;}p~X;o!`_hw3suAuQ#%JJFw7l>(cc3UbP@$!^&Sqjz|Vz0-PJ+Qb_QGsul@otlV7R-B3$uc?;UJHPd>* zePwIkQ6;z8BzJE~#Xvc`n@7Z8Ij3w<2vrUioMO|pa@24f39~{6t!_ogLDP&{leemn zSw=i}u077+y5189GZwf8jHDyUrsJQi358Nav-2md@OVX8$<0w6ehECMVW6C;pB;|k z9B?2isZnlFj*{W*bz*^xW!uk!jC=&Bn=L5Dv8=hi=Y>D+o!&^P2_;SGwfdPT8HaK0 zlO|G=WJD-KnTy7@Cu4W#2n|4)jgrKM_&LC$jj`c_j_3d~@6yCzIVN;QMG};3+a2v#Nsr+3-2#k6JaRCKZ ztn<-^F&Oh@P-UeWbogKe-3j{|>o{3NV8Pp!)U?0}_*poJFkiVv#!Lbh-SDVotX7vv zP}(lC5YY5!Bt|RuYVfJJu)IJ*POvg8L*c8Ly(B4pD6GN(OUXuCh-j~N za>EwmUWtVTsA@?|pBu4cknMsZf($U#Fd>Y^=e!sB`SSAq=z?e;G>Cb%X>zMbc2X$AQ$I}+2~)RL z_||9R)BOaa`|N&`$&711IUi~fkcm`mj1nBuQ3<=bB;X2cF#%YwTj%E5{My1Idwn6? z|2YCU`dfsfvUsQK;oYi|7goYRujKy6@QoK=dO=X!7sbaw6NIjDU zCnf3K8YqYXVd+ezY@pW90n#{7)#}N_47u%yR?<5%2U+P2o zX0CDzw?@no#~yQb@+s|YccgM67aCwSVkB7;XRJ)~IOSW5 zkW(ScunL)*#gSvuL+WA{$uS1?2iVv{B{iAuJ`#w-IS|rGCJk=Eb4PhdS`phB=@*VD zsS^so{;FsU5ni#3q}3bPF&r8^nqE-{ahA(f?=4B$(-HJEro1uG#Z9MjYGo=~>7!aQ zI@iQA1s0~zCA_(_CvX>n{-IX&Xepk*pJ~5ZVvwuyIhlP2LB7y(ifTsq+;Qf0w*z-9 zp_J3B$Oj1Zn7(Lww43YP?XtC@!6jz1Dk+tQ90S8D-i8h(tJf4jeK7dN;!97SE!J@< zaR3Lv5GKwUiCXdFS82C{WE5nkXHn}@CkX-@;-FEv$#Y_^KLiq{fftHEY8p$|?LXkj z;wk;`YpYIO^z175K2;fPyaV%Z#<>{g>>WEI_ZqEQh&Y^Rgc@IFo!qWhHrO`$t(-39 zh>+hypdHP%6)sR{D+2AMLrvM#PX%N?l<-|;B~`@Ud^iTgIK`jZY|+ITC(lMh{utt@ zL0)0j!^~kaBYe6#HP*{)5kMA*fGp4z)f^)+{1t$Kr^tcjNdObt5PDU8#AgWsa8gH- z!c-1IDJsDYq(kD^Nt8T6??!=_BqxQ?!qkFDdJJ5_@B(7}zV7b6XT>|0q0z{f^Eot7 zYVq+igr_J^F3jG5oOXbx*lXFGti@W&1j0ler<#FNnr3_XidfR&%9Y_FtF@gUR>860 z%?xsU?I^uPnPfI=3(Y;5l|Vz<97j<)gr%7lN!&Atk4CDXH?X)KhMc+_ z(oAU9Q0Xumpwbt=ej%dhn&sM8M5e#y^R`1ljypQ3t2dU~1%8#e^D}P%a${*?c}q(z z-drTh1LC3>;%*41YS2pqsjgjPA{~!SPQ}v@TW1)jMH1y^?B1t>Yh^U)Y8H|z zxFOglj4P#O130baqji(Qc0685z9<(XemyJ$5x^m4_N!PrJAS6RHp!2t4`E6Ykdjd> zhHhyoT3)|(h9il}d_t&USy%?mc(ra^VyWQ?F{8!))JGRR>_r7P%X!fS#<{cc`!lyE ztL#a+$%S%t3=hoRM8o!Gs&=w|N_9z(<#a&-%#>?}%D6sLJl;<-??m56%hGW$O7;_nr)wHOIjlNOt& zh>JqYGE3uxSL^ChC)Z`AGHHC6_i1z+5I6u(0nOhODV=L!l|j8K0$&<|-R>(C-Z~bi z(c~hq^^f3Ry!1j;VG{M!B=FIb;c$3r^9A?x0Ch8CPNxs>&rM4yC%2$+i``Exi#REv z?g|x`66J@7jribE-g+g9s!;*B~EJF=@jK z;#t}B5yWDFVzw7fQo6`O4i6x5A#_{8ybXBu%6vubr@=3X$75?gzUX5R3LYL*)JttK z@M=f&O>w5!O=M-azOnsE3GJ4@JR3N$@ci9M`n<)TL{ic=B8M#>}#wl2zs} z$2gv1#)ZJK%;DjD?r`Qz5DSJFj<~dMv(VC!-XLFMR`#pmLnQ_3{OsqgJYl8#BdMLsXHU&lHLlKUkrOszyrj%Fp&t4P6(c( zTM#9cUs)3c94ttN_2@s}_{r<9xKuM&tAo9#7*``@q_0~W(KyMEr?O}HyB>w4IDa+_ z@aAU@h?f~)=PYK8*ua&2=@`mjf=d3kW$wv`Jq$vF%T`Pj+PjOZG^%{r@UYt#yL)+` z(~wdc0v78+*C?Zrl+Kp`HW@f$6}>iiRvOc@w&1_%ao8HUzXB@GRgV)>xvgwgyeVit^JJ!Dy6DZ3Ym=3H6$wK8+@nga@iO#3U*1c@yXt zlTh*60oc%`H<+>HY#m=m#V7GSfCmh04Sc?F7a+aZ?IpGoDseSBa5GuPQDmEf(@~j~ z1$R=bBuOdaS;7|CNgkXQ%jZCgPr{=TC1lvbLQ=-Uz5mV90!HTc$+6u1i^(H8VfbPN zdiMPC#>$=Qa1lDYVC|dMMAX+Z1-v-9;@$-(CS+4g9FR^VAmE}zUcq@Z4psf6we;cC zHdz#5Bv!Lwe+>q;GkOzW>1{{9>{fDYcqhk#cjCy^z*H2wpcLLl@!^OS?5C5&m_-5u zif=)gG*+BeaYT8pvpxxGGk{yEK{$3ZX9UFHbkuQ0I6T4;Gap8qa;otHSQ7_IY$7~d z3x*h$+Vz*a2sv&C^VIdQLW!%pk{nC& z6=|S3qFxKBTa1zv0leDtj%cxDO*3Hh`pikYT2n8TxyVkyZCVw+$+8u8p4Eh`5|-7k zfu12i3|P{)0twmHks_2S$0-IrT(evm0%y2Enw7e?NnBa20We3A>vQ4Y1;tuPAERre z*?S8OM7l6F=PKG#q-jvn*b72xa|L-E&;gkRUqZxRsqh2+c1-B1r>@Fm*;hpSM!b=2 z)%Bc$oWSHz^XP!qGK9~0o=+bx;vnu_R-9!F&b(S6yJdO*(Brp50*kx zjbq5PFoEvkZNGKB`!feI8ja2@V+_jO#mM@VPDf)Q5zw*PEws`Jpi*@MnGl1ZL>bUj zYn-XvVx6`GIc}n+%4Q-e-)Ehn;m^tF!QStE`&qUHsb@K1OK~n20%bUxX>yt!0*M>q z+tA&)92`~P-qoON!1H8J7Mh){Q97?^IAzI0F#Zv$C#Vy7aYvztY6$fTr zad*o}+fe|#U?@{LrX-IjX(wZ09JWp`j!kZ+;l<=4y#|0MMQl@==N1}nuSQKtNi;T1 z0E6A4CZ$|H(&?5nlgckrhEd*J}R?9F{C%O~HBT7en zF~2yiVT*+~cpTO>cr zeL&1f*TM)jz#%|Xc}40H7|oYhl9ZG)VlIs4#}j1!(;6yrT%q1zNcFfHD2gzYVwB^V zVfP3gmek>6p@gKWG8DLcRB-A9UcHzNaGbPgJamWc3#lUg@HtZ;IAoSQ&a2?E9U&@y zi94dS*szcT5b5|3pE)|5O_0_4H7?lFsCe;{7c68~W}H#RY0yE3ZxD}FkVj(n;fqVk zuvikDv)bRtwhJ86!bGJB4DqQ4nsVe>B-t{fPy8e$rGg1HC|$R^I0x5UOmw#-qj0Z5 zL@BGHI-#G&z96STKEDs>gJU>=l7=&O9Z4WwvSd*n@uAx7u zK^)jy=LcgfuDyy~YP-f_s|ezf^+wbH`?I8K5?0NN_K&ja*T`DYnY2Fq6uC+3s3f;c z$Q)rm5A4moV1Tm>EjDF?M&~KY<}}OmlDzsEmO6t6F(1o(pMsOwsDyqy5 z(1)4|^HRbiaQhh?-~ke0K`KHUMjZcKxr4v~iKQoNwmT`v=R8j?50)KT2@cQpaYlIk z<4(5m>^#p%m57WB;D9qDBUHnY3H+se>Zcyq&QzpI(s8;lQ_r1SmtM>dOzP(2aM4^F zGr1NK+O=#n8q^gN>R=bDnrDjBSc*Hua8QdXaM02Q=;L%bP7bpoB|)D|IYCL8->*#p zco_t?P&(kdTP?8s4Oc%IWJ3zdlMGg<@Uv|;sGU)LR_q!~^gGZqqIv4A+>5qFgYd7(}Up?4-?UpX6eI*WOfg2|FME{4(ZXQRWDR)3rYjrk`svH7x)MSCkMfOQP-h$Or(+M+&cQae7D2JD&zTO|~PT3%g>5y7JxvN#pGhoTaC zq9z7b#fxF?l}}Nq;wBbjBUft4z(U{<0VQWxiCXB4gs5)8BL3(Yu9@0Df|Fa-H;-fH&T}e_M#qo79)Uq$+7S( z5%6d|m_pe|#PP{g!3@_oq9o!cco?UK%C4cg7D;RX($mOz-e#qTZ08Vj$l(SsT93Ez zEeHbV1!S~xjYcRFrx5C~Y@*El+u#lfj!9C~nfuFgPI`UD7&;l+RIGj_m>e)>;w(59=hTVrkWyAT@|{s9QhhYB4<66kxv zN0g{k;l`84F+|vnV+m32v_UL~t##Pzt^HJP1UmO`dv*X2&vW?hD7zr=*Nj=rmAvU7 z%*2p0{IIqVNL{c(@t2O{z=%4Ad=ZTF@(Zp|vvV@py>93zthd5%=RGVFHduNi{W5%K ziE84g>*fi_iq(1MvS$!r49!=Iz0l!+rgm#g z)!krN38+9N2Ttf^Lxic|Zwx7(xI`#pJG?Y4Y=nd@h>AlVnT~>r$XhQA61|p2JlCq| za@>(o+C55(4yO%aEPNa#I07|I8{TCJ4T&(Q{5J?7ZUX8z&^f5Dqyb1+F!w|z7tofG z+pX)eIuO55V-btf^3Go^mY#xv;j+1&U>|Ugrj|}D)&Pbho_PfW${`{b+ISEP3;{Qy zhlAIR)QUoUY4O@mHi91vVEMTo7}8lPL^?%D^TC0ZU=yTHTeDl*}O4!&Ns& z*>1e|@s9g=#9fCWxZd&&S$IVSW^--7Be7r*5i~^*HgHrna%28t9_X`7;Aq)gUqh*# zO*V5HghL!BAuvjeOzxG3>*H9wMR_Ti&bhA7r4t|6M z=q}j&^e|X#cfTywEg{FKFnC(6dvRO&byRsVSz94kTw8sBhBK!l^?7W6xdt^daEf{& z^w8LWsOUBZ>7n}WW{CkD$BTlkWC(j9v2C09>6pMrq77XIlGIybywrKNp6F3 zoa-TzFqFlS@!@lyX;6*<7r6+)3%!XJLy1k+a$+UAU_ylO=AVPpb~Gs&;t^AF_a&gq zb`FTLdxDkwAjV2zf+{o{^;)R=?Mc-a?h4Uq1Wklvr!woSAmB;S$rcQXhC8Cycjib;FFAiSU}@X zGV__V295$sJQf77Nfn74z#_u4wI!QkC=fVcU;%kpNvg!5eZCk_TkJ>&OFvxp8Xl>1 z@rZcR)aDV-Ew&a)$vP6-zaq#rxwR5IO9bd6)!AIDPZg0&(MTC$;Cb+|Ea8e z32uTV0M62+Sdgq{EfzHT{l|*b8RUoEqV-H%2WGpvZFk_@Tt$7UPhW=xX1 z!hx4_QV0yi;uLr2iTXpsiDk(gWV(}6-Gw+RVOBPtPD0XTaM|K(fdp?k0ln&8(q_F2 z_GaBidkjU&9Bt+=Q7-+zWm|*PY`btjj&3i1l_@2c-!apQQQ~5q(Cy;E4?t16uya3Tfl%dg3lq=OGr8slT0G>2dK^`J9Drm2y-E-i(`Zuk6AF@l8fqY4ds!L-B zPo8>sMz&J`P3er18#oP`1VBmK%jKgHco`WHAOhH6$noQAp84M}$RY#$lOHhv{>0$` z{0$CIA+utr?CeAVhH%8OLJch?NkR}w|92Ch@Jn#9_%~du_a`PYD#xXn{r`!hX-=Fp zYUk>HUh&EK63+jesH($r%xVi z(QTp_Uv9aQ_$lYuFZ{mY_jtZnet9Nt8K2`_ExNm9-=FX5HZT3bCV2Z0C1c{f)|ild z_sVB>l$YEY*|l19`*q&0#Z@D`*{XHNdVabkU!YC>PZ5(b7aD1;T{cqsP1D2k`pnat zs(Y`0tu5(sWjv#YqdytX#r0WZK|Gi@izq#@z$I-Y%IV7h|DAl9e|GAo<_Y6I_dyVexs+SXJ54Xg{Rjh5@Ea($X zjC%%SGoD#_eW1@+b!YIWh4+6cTHJ8yw)fq2+~~ShB%M>)|8U)-x}Wv89jD&@a{H-2 zbypW>uX}bl^3ok)wrj`BHy3}fxOK^(#Q(+y_t`&xsl07G8#|J3<5Ta{QGXu2_Hy5f z-&!eSPrEBi2YTur{P%^kYwdUbqaHZ+(m;s!uezBN!y^-m$m4kr=NnrxU;BLi&)0wa zMS620^*Q<9|MOh#zc#)4=4TgZyEC5uSLXTGCjQYGm$c=>0B!9NX*9@NvUXX*-^-UI z9MS&Rb?47rt!1m9iFbUk0Ij6`$yIH>CA{?c>-$&5HMSo19FaR)_h;@;T$QY^Dr$Hk zrSHqXzy6YQ#s2^d)Dmzv#$UHbhrMw#t)u3@L{hu=fDwN zVYK;rU3h}q+iI0P+@1F?=1fpp@nQus^oG#hD%6G?yRS)}0c4yFb=lQj=l>0CLrXHu# z?R}d#e|+-QwUNsQ_ED1$oqO+KbZ~2Hdipc0dsU-H@2-~iFY4=4K3=}*%z=xQeQ!uI z|INJCXY$_7?7wi>^uZ72S@QL^h~8*?yR&7}>XO#cw|mzuZ2NW1vx&CvEAKt5`$_-P z$=4SCw)mwpB-SNm#=d=1|M`8@mv4MG@ZTcYOO0_KO#b(|HPdhBd|CZrLc$tV%ALNy zE;<`p%GvVo)vqeEXeziR`6M z&h_5V_y0eRz62`ibnn0S&fGhimK)-Z7u+x@F1DCUdWR*~F|i`h2LFPjr8B0JhGzQC z9TWitae+4Tg4v3rptj6lHVUGWCXSi5*tq6afm>>7|Hrq}IoUa$!;feAem~pu{M7J> zx%0>0Y)=c!cJ_R|YF4r;C>MLq550=i#Cv0PE2!qE0VufvOHTT-Eo}aAQ_AOEa)yYK z_&G5?;5;OMF$9O0`VbbmC#W-H{$}K5yNp2USfXjk(77yH6}yA|G+4;{$i6bx`DNQQ zbnQ{(b5Yv-xjo)C&X-@i`QHm<#4++tTWxj)?0Xq#jW}uXD9`z6b^lC;fqd7tr<#h# zpl6ST3p@NYgr4Fh)OSuq|lZF5TYs zR)2&pOZFf%+yqK_W#P|Eq(1`R6yC}IPRwszqwehAgZHgkc9{8Y$act361Ex}>Dc5s zALiFx|hC4 zMYvP46dHH{<@L#YQKl729zPQAEhkj+YzO>JOsN$DeYnkC##DRH)BE_C7FToeH8~1J z95(!)PGGXeJfv{A53#y&$&*UD??k-go7V4n>O#K zKaGwkPnjhwxdpaX9sP|qANplmqI*y9NVtmmx)e8mJ4tAK4$;p+?>Z3P?x@^;tYzrX zmu&+Vy$}V;#tgra4MqjmQc-WfelC?|O10`U8(vQ)F2qUw8cBjguGb5uLTlyk)blQ0 zq0)%NPL5%tolxWG8EA>%o`|RFAHreMA~^S)KSg^zuAt^b_=WcgERYs zb+3QyQC)_fo0Gt9WjiQ6!IDL@(E&$&T~$4c;Uzqk(&<^rhfaShMAxQ5kN#R*x~Hso zXGm&&$s@l%Foq_F8oET{cTx5p|EA^3HW?AEa8a8ku8m=l%->LRnR_&j13cp$oGIlF zLE_52Fs<4sYfNzJ#g$Jd9;=q+CdV3a-J`6Ywvxeml}F7P5x_FC0C0~JZaCszg^3Z} zr9l45!j4H}h?||sgrYpc*j)ItGm(jD{`Ss4KTS&d<(5xUs&jC>(p!V@(wxb2+nMQc zT~(9t%=44sRaa@tCNJ_DBgk`TndH!2Md#R7rI+5UDj+WUQWGdN!VV*eOxG{v1{QGD zoKjJo^i%U(Gw8Y|?e_YOkh{xD_y}zQXI{TB*c|jqAH^SHShQK-y40uqiaT#`M=W;0g~`8p*IhPPTX6sK8|kki=v}!>o!DM!Ww)R_Ft3!A3M=B4N zYW>%Rw>Os+nx$9m=wWq5%_&xcrC#4CW$nJIgOHMHky2K`aAjEQ8!6Y%8v8ulEX-b2 z!Gj{WIuX3s_%vg57yny7h)ltuah+c$1i57;Nx5xIx!ftTCQJOPi%!dhtiMQD-!ZDZ zPf>#^Ez!#N_ack~rpKt#ClgG%&+KX3x zTsy*c4{VgzzTE><>OfpgHdM^@vXPxv%5D+~@kX(v5?K9x;ghtP6C6{j31Uqv zt~i+CVO3Wo?eY0Z{5q#t0Ns`FcvKm5|CvFfk~2oz-F=e@HnkI+X?#Nr8dl+8->M&m zrs8|lYrTqvS7*GCbp-1xUdJfevf+w`0R_)W&6zaN)U#O(lPSS~{ZoDo1pSq`%2fEO zThNImE5pqhD{1m}Zo@s~TA(TeO-}HW z&CY!siwfh_)xYlx9imlQjz@>2&Am?B>>TxK+tsj0$#lP1MIirm+@xc(9Z?`>6pvJJ z)sEq}9CE{kH&RVLM10wXYGIUoc9w*Rl9Iz|GMFtd z!V!qHwLP7h&fq=^8apv)=cO9#cwncrp4WyF|1u|`wfCTR=rGJSWVmTEgaoEyU)g4@ zQ`kWB5p;}tls(;Y2CqEL7(oRLm=}YOD;P=&R^`aLPIkRD5+ixx}3IcNI5jfOj<)Rglmb;8#mq; zW$|1(beU1lcdSO&c$`rlEG9Z1yoVIcKDkUdotSc>D1b`M`$J48oQ@r^W!L6<%;3(? zO4&f$A{g(8hmc4o%6?7GY?R6g*-?5GcYte&l&H%JmGMax#mUz1YD|@To16-?NC{j; zl$bJS_Q5AY<}wY;Bx%o35>Y2@lvu)o+DS-h)Gi(}Qk>jM4dlV1{RDpum9{YzyIy#_ zW)QgK)ZXhsnuc>^_MDVo9ot(F6ux10Ag%_2PvG|Di=sr0MEp;LQ}c2xmSBOD=?FWr zExTF?#@oO7R+Xv}_RBEw5MqC_V@j%1WHs*R=jDe3krErxJez+D8)d(673!|60SLg? zDId|kw?p{C5*d+-Y=oELC|EmBBj#MNDS)ufuF9RkX2>@q7oB)P+U}{#bOHkv{>J%H zJZ5C#J@vuo60R3XAwq(oI1SzsL6Ne#NP^Q@ZWoUDrBL~;=Y?d{|)n3oZO zGa6F2kHighufL9xLk{xYXa-v$Ii(ai6M2w4ou~?fWH<(oIfZpw^K2K%;@%sX4r(U? zN9pPj0i*;)B!?tJkZTkO5!Z?!k`-=z9Aiq=fa?~a0tRn{q*>a-%r7%WBvRK< zn*y$d>%n4UE>_GQpV@cNDd2`TTRI+5X@%k4K(ICX@D$q{$=nF zwwKg5zTb(XF=ttMmnG8|;$~_clV5y;TMv({AwiL3qF)6UN%VrC4h`HHWpP_^!6y;i z))ZxwCqcMusPzwDez1C7bG1UxlyNZ6Z&h$)A zzqnSi%#=2eX zA)Cq2sv)FuH?Hk-P6~_b^&G4$%R*^}*Wp62q)eG)shkelb_@kRjcudP6LGjKiKH-e z2Vhlyx5Tz(F|){uudA-8WjO&kks%#7TS2WpV)UFd;)P^N`l_A5wYB)$eDv2vtSk%>@YI6txx-=qCrcy zM}~aa<{IGX#8U}Tolaruc+kBwrFv!Q@#;kSM<0P)CaIJYg!4WViiNCNDD^2H5Ukj! z1%fqKvm&Q3XrOqIrOno}_)R^FyI5;!344kK5P*8ex}56;A;FL#Aza5WkEkZsL}o4zkUJ|7g_5V`G{t( zZKEWWr%@R371b~|E>eoqYMHWdW8QSb+?fK8t8U}9rQpjY0qCL|tzVQ8V~A#7l}zyb zFHor{#o`u+v1uOF4*4zBrh)-b%B0OE`$*+PGDT$34|dQ!oMxzhhLj{jE%{aA3;36% z`6HEPMImXBFh{U!2#|x7kvD{RQW5~qNq{~er3ziYWMmcxv!gS~iLvgiz3X(w*t&=} z&C#7NkK+U(QxhoJBvo_rZVaVCmXCuz^w)qT7T$yAR!FSQ2@_kOf!|#0iPN{ z;=NXfmm6kh20q0^$@__3$H9m;%8hDK*^;7WbN00I%eMQJTnv*b4;Z{O40VIY|9}@V z#B7#faPGW6S%c8J!Q~<8DEVl+)^>jI()fXPEri2#)#^qyi1kNg4a$clWAMyOOv9gO zVbGL9JwkU~DW@1}~fV6ZmDm4fdibxQb zqex)ZX-ee*3NvDkDx$o4qWmF&0_DhCyw}Jn%1lRIE829d! zlxE@Vm?^1Hw5!MtZycYb*u3g2fsc&HcT8%g!C<4(7l(4MqLF!$$>yef!6La~i*7SU zYdK;VwM&)2LO`=w2%;gitBi`qB1N{PMM|sOu+{Cb}86*vq}C@tN-vBq2*$5 zFsSW#rdAy<4{u}A=|UP9ZaN(X6LW3#?H>5+Z$H=(;+YO!v1(%?otbKu$O`{6wk{0S z@}20Atc8$Euowl{v`a1Wxr&CmBeZ?01+ZKOv~8^xP)}n%Vbqr_&uX)?J4X^M4 zy-QNX+gi!)-eHcoIrp1d5&809s^N`I7UMl*!n*0yMn5Uq%gcs`085k#L;{2>E2^E_ zss?pH4RJkK8D@{&i>H3EwLyvtdL+TEJ z66c;*Odid!hXoeQr6xOQaj0y~Cb-zZ=lT$t1|t_7pu)sb%?~zW@w80yaXsB(dHC5P zA}(VLnLAGXG)q=2;6O`iHbE*jDp@MB7FEQ5NAqq&8v&Wf%E}GVA#`xCKn@DAtq9J= z&Z-3QWwfLBG(fYosD(eZg`-5A^DmEHF1Q}#yO5KJewByWEN`uANW&v0R_MWS3Jb8z zVt_t(2=zM*MtVOn!bG+F;2fMbwN$5Lh-*@_cYD25J{SY-_jwXmcNzsxku$*#m6=O?!9TXtDRr{vw{Cj z+&-eKH!C#WJ0+n+r9~Zq63R-3Qz3`UHSFr8p=_7+b(<8Nz`cvJX~;7foqQoX!6_=kZsWg&TObTC_7>S-y|tWoCAOihjLeJr{Q; z*JdRdeJm)wPtQX|$Q3HoADp6;Y?1}x2dt$U0H$GXmsKl}F5l-D;Ca>Z!HAd!c_zBi z;Ie@)5%~$-#?SBx33UFgZ&gWA2-#U@X91t{Bq!myBa1$?WC(gF(Ws=M$%9+PkPD+y zpY5;BcF?LPKK_kT*Uz4+3v)m()dkb#4379J+5&0^_1q!&6NmN+x6Nmllc25&eob~Y z;8GkRI3YZD-jNgXaU$ZV|4v3FPxHBdjD!9hR-R>3XjnNJ+`b1=?V5wjH|F%-UHYI z#fav)2tu(q|6Z#ViYZTGORbiIN#q-z+kQ)fC2%v@s(+M9a#8Sj(B(Ah5o=(`K4RB&}4fqp4n_xW9&Op&1pQ=f3dOU?Jp7D!YMUz-` zKA%NB#?h!AUnUXzXZE=U$U;XLW3>~7fYLAoU$*Vk*LS211+=`09UL^|{fuamop=mt z3^U?L%)kOg+Jx<9(74EC>)%C`3t%y-)PTjO2jW_)v}~f$K$gE-da&)>6|7HARUf z60gqhM&{MnG-L-6a<_XCSPvA7En$lYIY3xQDL|XVexjuxKx(CcTh_*?#kJN2`vN?8 z{!Sdl`c2djP$=KyCT!+QQ&)pM=D+DU?}ov22+Eo)FMC?jtrjf0%4_JK1wVHvJFZ#; zM~5)6IJD94_Mpd2%46!BSACj!y14u`FVActvn69H|Ekpx9MSx|#=6PGrdmBRqa*y- zP9AJW0aP?7MMi@SH%Cc4*alK*NGNa;nGovi+M9 z`V#r>D@ciCHoG?U!qD23EU5L;@Rx048%eqMP?VO7#@VI1Y@54!UY~)%DSl5T(+Sr3 zJO>Ad0m6v1P&PPt9o;7MtmOE&(sI8+9Ch;s6kY@GkVhy(b)f9gI!{?jG#Ez)U3Dh=_4l8uNtW zRW!r0#d3J5<+zbljsBp_r(u|^a1s}aVn)fi*#E}hu znvPN`B6%n!My^D3VwB`zR0Ehl@(o`og;6BO02Gx~Jtd#2H_+c~QTRCdg%kih1q(#5 z4Y93@@c4;rFJq@jb~Io5bN|#iKhWKY_?d&CV)tW4X7m~s>z+5KKS?qo|Im4w&ZMiS z-rfX&L@h1{gvb#rQJw`D%>yXPD^nnHg}15KQuQam)a=g%gilW8F5zQjwPonAXGBy~ zuLvy9dTCCuDkt$^TS{v(;b?z5U|GnL2XE(Y8- zO2iRkBRM8sl=%|2-3GyxomaRMKUybtUdjC1IrO>1_GT z#(grcTil#owHf9-Qv0||yC}uT5l6Z?B1-m9cI`)-{2Foj5}B-&Ay{&zB%Y>r_vF%< zQeBA zi(VNT&{);(viW-aoXrjahyS<#9sNLrtMNUVVG`DaE{|K|3UvkNZ`-7&ivC zU){R>%Z0B4+;U$Hnc$C)a&7AyDOuPdlVhyiQ6+Lp3<-%PheJq#td5F}Nm)^LrP;z* zLvd!=U$dTR{rxd<9h>`-M>iGuU2%Ur++%~>v+LxwpqDv2F-i1dK2XY}Y>V;`x*b_| z$m_78UB7{jT{rPrNq$3}UH6$GGd`Mq#l)=(`xcqaGQ~V=0gN02j>s>E(-ivr{2G%p zmdLn^IZN^%R|2zJ;I&Q${rS+>uM0E~$KU~_$IL8*T>hdUlMH&dZ)t-}d)-kyK zU=f{e+a9IEwE=psBS7|HisPqoF#$U26=dDO#(CbGDfau8w!vnv1MUIJpjI$*JRRmx z>M?gJv=9r0Mq7gJ5F^`dfwh2~1N&Y`Nb0R2k|wbtQi>5I25q z=v>|)u?_dX&rK7A@R3oRy?q;#L0eK77JW^#Th`BjkLd+_9rxeA&iR#RY-uE1zskrO z2*|{(YFAwRoo1=4SIf6A1h?aw*w}e8h+xQD(R#UsYSQs*SUVhJnTio{C*w z-{r?gwAreFI0XQH?rV;jl`9ZCiT0`jBCZWbh!^u5+F;KHyVThqp}?F3E~`8_WQJ`C zWHeByj{-U3|GqSsY=B43`2iQ^4+6bN$oQ-Szw)au+8-S~@PKfE^tPia%ZPu63!rGG zo0O^O$ji!mJ_60-Oc+Jax1)U}@GW5ze6#Rhkqn#2+&I*o9i{Wc{_<}equL7!_|>*u z>K&G_{{3R!;)%x#*~=(}7TEH;0&()!M}cjO(6;H6R1$J3!%Ig2C9#}HIK}NYrsa=; zCj<5Dg#;Bmt>{r*T9zLg(3&OePLkaqV!L$lv<{9bS#IJ?cUjavGrSVG#J%(l0eI=@ z@v526(h#B^F1gsWCBTG1!WQ~E4NI2D1dcZ~)G74eD^oLJt|Mc2@Fng0Fy;HJolDtQ zv@kpBORo&^j6$mh9y+Z@^V6ew0Nb4ZdGow~WsiExp5~91j8kF6>;USg72u_CpCjap zKD=S>pKSI-dRI0jtC=*gdunDYy#IHc#?G89yFT(Whjk{lnBDS zOtX~Dwu{n6rnK4X!mxI$iGIigvcZ-L0iF*^c@6kjC1B^;=i>aU=;HRnXmJvSJRK>-Lr&$>c6@$(B%f}G(7Y*R2kc5!qvl(kaTN$p>EIKvL~a*cbFy- z-@9||a3D#=e?*7bKc6ZQ;zh+YE+h<@jV8oz9@h40ZEk8oB7iZSB|iiJK~_@s;N@3< z8!HwjBfUmX7NsyoQku14<}7#WQN(;<3vdip@-+a$^a_lmB#t%D%HWvp2Zx8W{3|ha zXF>wy<+WQwcbqsAW*?q`AcH1Cyy4l2J%s0=EvTnvEA&fZ*SgZEI~gt;jAQ9m^B=nw zV3C2`h;si>X;S&gP^Z&%Qxp7ZENTChHXIBo+uzXD_9m(K%eHx&vD^tzf*g}X;;Rl; zI)xUdjJy??{8MGKMfOnc^BSkfhv9e@N&?+tKq?f|(<$;loc@`d%$)Ba_@pW!)E)g; zEq=FIv#L-dQs&471YP^@>6$Xhd>(ag+52>-(m3={esY;8?&R_P9*G;FzyGN7CI-!- zYdlY$w5^1M9>_zCuaz#ibMVPKj1n5@xR~ZyXxvS$_RF?ErR=+CJ+-r#_Yp$+#O9&# zRBEbTCaVL^ixGAxemnM34OkHf>7V~e40B0J`-wMJy&?XSL&gG>{yC@WgRn1r}H!dkM>8tV#2;LbWNhetX3O%%TV*@igNwfsxL|reflTAoa?UZW#=A_ zC4yQ$J1Y3meN9`u=XI54wQ$v|&Gq8_{Uc+y($Cb~B0j10ifLOOc9u+SG)?FJ_C~Sc zGn0Eau=zv{;|Kb3?Eor5i8u)S84E1In#FyoQn~NJO#~9>DX{1OO^2_OZct%(j%k%s z*smXbgXp-p_kE!v8Z!N0kX5+gW*7eS%{9{K)tQNn$k64WnV<>z?-ze}Jo7HlIxv#) z)0b`c$`qEf$cL)&)WU1A+=o@|n@3cjTuVO=#5Kcf zUlg0KoI_e zLdKZ*^*cO+uCGG)`sPONale7gTl^_3(y_0K7N-OJmEv2v*|z!XltLykEm^NjO7jYC zvKCi&&ywrb%cv(nsdiwBj8%a;iX}i?QBlI+ zqmurR8KhJ2|NOy$M3oel6Df3r96LXij3G-*X{7y=w>j1)m4;2Fc{(p|Q*pV|ACA~N zH{n&jDfwha^jythy$LQQ5w5-NG~5h}`;$)%;&mGqGA_n?c)1(koV*`%BVXT#Gb5Bk zuguJhl3!}1Lz7>&?U-4-KrqwckM9r{kWz3UiFF~bdcBd@I#s6CVWzX|ur_idEa2`~ zET^9c2?PD_*0WC=qftp9N^M)AkUd9Z~Dr zaqH>XbkKn)zJi&lbbreVp&Q7GRH2FUCv*E5_|1OhqhDLx_Gt2E+B-wi9eEDV&baNZ z*BcTjpV%V9g=UBD+?(D@x#iKJYZuJIyn-t}w9wx$9dw_~o4xwE<{&yoV+d&_msk{< zCK}`NmBdhG{xIs{5x@diD@Qhe8aut{Y}cEU*nSQO{2{6t&^x`S=3J(#p0B1$A{5R; z*mHq#oM)Hk!&~w@Pxr9B=NcYx8st7d_6+}{6MBGR^G?`*jg1PeEHHrmiJCh=R;j%8 z&z2XJ@`;bsTh->m*r21h=S=m;nv5DNAbx1fR@{$EUq|Kr_eSnCpfxE%D&wvlX>KQi&vXfjRyT56pPdNWsugJfvI?Dp$vz5y@2kL1dzCIKlqR{vLRnUMOGE{!^ zKZNUPn*hY8??Q$@i}AGxdgM~z#6R-+Md3<%=EtYXVv^hPTTaND3#Rkj_-E9SCxiO+ z9ijsVe9ewFH1|#D7KlnnuaS6BBKt+1EStF2wYlgk&^-FR<>b0=czD^q+8mNP}aSU-& z6|K#=neb2mA$4TQc2nPN{J8*A@zs82Bzczafo!qvq=qZ z$fgsZ3;-eB7nFmH;SOhF#+g@LKWCh3uZg_F4)vUh@h0y63yuHP0WpOno zW>88Nfy2YA^YdBy%a#Z6Ax27fk9?3=4DYh}73dcK2aEybH2!y$b(QsgdoSnCcgKbf z1bsDsuoTb(QKxAZU7Hc&Z7zg88}BUlmZmnk+s{kq&P(b*05q; zKU_p6>^QRs2sMSNl+`Ai^ft!8@v@ubOI&1OK8TWfZUyi59QNc=tq^KIm#5gw%xXc2 zz)eJ1hUXsOAc%I}Q67Jba<=^|yf7!Bny|ylR@XlT%mNM$MAVAtT3Cvb7*o?Eo+^WZ z%cK)m>?ru^K9_;^xT)GXd`@L#HFyt-&7Uyz5YW{K6Q?#z@WE&k3-gjjMaN7&JR}lV^{Gfl0%j0uN9DKQP8sGJ=4134J9LbY3Hw#s%E3nT25CfKa+mOJ^hRv$o zFjWp^#SHD9?O&>+dpYL)bg@#PNY$`%>v(a;v@_!1qm3}4ba z8oFc0PFEpD(%w@83AF@!1DP$Kl)Ft!n7Cn3v?)x0T&!!d@0meJq&sE@e5P_WE9QfX zKm+elPquGd%*<`Ni)t42y9WD|6O5$!S6Ts95E4!e4T2fy@nnvU&m7Kt@y|y|tNE^4 z^Ba^cz%Flic++z`0aU&N>0z9ZtG1n%`04@P~PD&l8t1#fT6WEEy)t!{b_2Wsa#QCa!PG*8Ov6}z%yg#3Q zxuYHY(Qr)ZboyE;%#~|z+uN(xw`&>}2bU$aR7C9(82IG<>_S|_+1cOFPxK((*z*16 z_O|7;QitJ<#uJZ$H>q#-V%)%kY;z&U*!T>uuW)R=#jVuqU-0qYE>3;$blz<-VS{{x zI@ws$Ik=jW!=^U@?&Va_Gd6Cs-+7}ju4^vmR#zZ4Qa{)Z1}UUuusvYkzL2D(QhTsT zECi6KP8%+)eBYs2vjo|fZ4!Fl0$E1g_15g0#Qi&AzNSj0duH46iD@QTA{)3yXRL|G z>llULo$9+&jqo8O#zqklOacVRL=b%a0MwO)K>vMoeHj()FPsR(HCOg%wv=T_`p|rp z=boeE4G&k%u2g;57EGUTdzz!^%DMH^!|~8kMyXcos<{m0lTsXz5Ibr0T}WBD*#(&P z<$~HGJ>$EwOM^m!nehb}LfQFhF>Ws6!oUgnT59;BgpndDlyc2Wq!P)dUY=>Y(*)G9(AP}mFbud@Av>HDPJwH>0iA(-1F`y`Rkv63h%Ag;gBUm z?$l&cW>T6RqbNyQfB}jwwH$;uq)pQMu?S1Up!lB?3~LdZkhEc)`0W!JNS&7~*JY%} z<$t6Aqy0@tM2yrA4+&xNFsLwGtw;n*G9N+T69(BDl%*y%=}OSAMdCSq~gMEb)U zp2n3uZNfqD`S~vLM0)+WFZ4XnLR{dAp0>+_DIaovDP@dCl!1EH4t#b|Xeq25Gr|~= zkz7pL`V@vG(b7Czpd%zRCVu=RJFEZX%7II;uSRB}?0dQv+(2_b$x=7RzrV-N3v%L) zw|2;ww=ctwLt_(Y-0i2$EUa- zvhV7irgiCzCoq_#k`ieKl4`W-R~!#Nto}*@fy3c=wl%MCI+)}S4D3wA+{`&kH!BHQ z8j={lk{c?zmthqJNgIkm~T=;{ED!QHSA8#`XvUIr>E67?Q8LW#3 ze{mgIok6?bW4q5hzyj48bVOEuzLf-qNfU6Y>}<_B1Y>Kii>2``^>`X#r;Ffv_0PQ^ zT(t!E25Uoh7#fI?sIGpUSOQNZBf_yJF#LliMe0jzc8p-triA6^@<+ogttisE=# zCMrcqjRA=qSu=$|%fEt5M&9!q5LXW)nHMk?dhZ_f1g4|x`E<-ca*W!{CckBcr=ARF zhKb{!rY7553pzfMbm@i%OSJ%XM|F`P=9_tQj0&YVKhDwI$Q%C+bKxKhr3DI&D0I?I2ga}X-4wkGmAYf1865{IqYU{sJXib3eRp6Qq}RFn>s2QQy1>eIBWTJoo&AG!|3RnPY8 zdFuC!(T?JgnH!mH!w2*7jj#-1E*>AjL%61`An@2?9>;tva6fTm?uFrpFWc60T*EgH z<@K}4=f-#Uwxh&1IC*L$IuS)%nO;^e|CiM4t99&b#W;cLK}%&5x>gdzY$$Sd)1J) zF?4&BFfrS0qY4|wuU?ye2fC$18j{e+WC9C`xrJ3@T{S$=kWqBC$k#a`jZxYS3D|8r zj3)4$B?zFv{zJiYK!(^`W3BHhO38q4@qgdR~rWT9Z!_hXtH5v!Wu7aL-$*mf2;6>LwHM4L3J+x0jk9x$! zC;>FW? z${JgZs%q!}IJd;Ew$*C`7nK;niFX7%(dxz!74Gj?QHoj$Oodnw+l$qDJe`)a$+zunk#MHBgMsQ zc`qfS^Or%?OWQrVNbj=rvLIxr*iEMy(;%q>IL{XJ2KF5IX0`T9_c1?y*@pN8))I(g z7KVh#WWzK(A61m!fh#%cGQO5J?t-v-sNz69R<9s8PvrY-F!p~XvSL*`_}Xybr5vQ7 zJr-sM2Z8v)-rjlr0?q+#wC2#KMdj9vQ0TBNsXPUEAkDHArUXs{hg~bh_{$#o@2jW4 zb8J|ga_r)q*B|?jYiB&?||2COEemC92#=r5G?Mdekd!e zp?=s3`m9&(xsx#RqahXpMAA(1BvlZro-zP4hE#%otXZ8MkG2SmF(b8_y1Y@R2^(1pf{ei41HUG~S2Tr|n+rt@` zJVnTtZT3$eB=64knWnx%HTzZ6I^j9-6Ep>TF4{^xR)53SseUkD+NbguIc;I#!s_T~ zLH_d3=}!yWe|;RbaxLq{@y>(uOiDML#+N&Ha=$1wg!!bVOA>V^G+-utlU`* zXk~&otBJ{!4eCL-H0ig%_Mq<|QA?$*7u>1MKwRyS-gkZvo{b| zoOhDULx7_#)rlT-N0=G2EQcOaOn310Rw9uC^9oMhohfE|5}E zP3JCFfSh~#AvODSbrP#RZTobNv&mU#_FWw_%YlT~0{Ibb*JP3*V}TEFH@w`_6w~uJjzzJncW>2|FILr3LWT&xN_J zu+@0!K}w))=e)kZrZqjSF}%2JEGf->Z^ziXI|N1%{Uz6LQqCkZQxxs4K-9g*C?4hd zm1C;w%2mJb+_n8Y%{H z%On<7SjeJoiBc#+iEuD_;dPPPMZPl(qWl#bz{<)=TgXf3@mz+~aw=IpYVpeLYoV$% z$58!H=gu4dJ?MCi&htftM!n!y6KHY|QL`x>m7U>=8PykPDtNY^vT?1ShdyGlmXKhK zA{vcU=(Sd;=2Y(uq>{S0pNH;m|CBw9eu34+$J10k_pn$jqcR^Ja1*?)@)BQ@4LqeH zx!v}}j>Ew}@sEui7*jvPyLt{@0-@fc5Wa@CA)?y3-09=vk8nHF%nBz)zGwUqwRyte z2d32dmg|2HMvWeLMnSk`->6(mb5(DL7F;jA_Tt?+Yn=zy*qc zjtpjt!C}frHBCP@SJX~*d4;172W5Otk~YTN;`!U;=W|c!Ya>nF+LJ?!Kxv)7|A18tO+N?zf<0Qe+3dMCO>WJ}_qEG}b z3INSZPTz>OvV!CzysaQS7fi_5Wc9d<_J{Np!Co7WOW&P%%1L+Lg-;xe0B})I0(@YQ z(E$h|;Sq8b#FE%(JK>A2{0G~EO2t`cJ*~!W8CJ@V2%hb_d86-I%8L4{yEofAi=;d> zIQ@aPY=hOsIt1!P&wM~kU7^Y|TiKpC@B0FE8KGZF9UO*v1vhkk(ovuDUK$1)zCgYLF4g$HD!qODpJz6KKF1&d3M09_JbcGC7faK5RU4hy!K_iI|OaCw9t zcSaXVwa&W;mHgHT{FiOQi9A>F?kc!u-^iRhsj(&iubChTxZDbIO$jZM^K22gF6vSjiR?}ee8jl#!fu6abYBX z{8aE2!R8g4`IJ>zUPoXoq%f?oQ=vY%9M_Sbw@5*co0R9geKAozVd#X1yS$-zblUv+VX-LShv$D~q3i>&kFK_Q!V z)^CS#){Ka}BqLdRC9<0dJhV$51Q(thqou;NzaWa`r#L zxMdl2d=3or=n5`5TK#3)ZNcsuEq*m6^4bad_4AM(>W{bR@<6I|(lCD?d+c*o`ewFkCdUNwz>!?_l;Tq@`oilkqMjK zzS_nzf5%e)%Bit&dB?|%ll;(?XgBZ%qoJLN=)zr(6UQeW`0m~KeGez3Ok=6YJI_^F zbY=L>;(!>zj;>z-imKbEk0DVFW3%Fh?vc|taxV8%z zr{;*NT{lxa*3y{KjvuhK=!J}4)x$@tt z;C6!Ya&?z`7&S1mdcvbCN7I=Ixt&uz>Gt$|!=u-$%5_c05wYS!XGBrUgZWz%a`A|K z(o9tVSDtNC-u&&E(>M7RPtuUmpc8;8C!>xevhQ^ve0{)azyLRKtvG*iNh;5NQ9H@C znIX%SLF?H_nT$e19XVdZDU6|7IRCveAJNhA!IzJ{RK@Slk&Xv`8}i}2TW4a&d4ET5 z4=*c!qicL*4*w|jxbZw?FujYJW;gf|S1I%-0*#J{-p$N;U8zO4$uUJzS7Gne!Sb`( zJ03q4ws-C-DiQOln@V5Gqy?m;Z1i_#`^)u%gY(TK_qYk%^Sr-&YOHH$&74tgw|KS% z3q?hII1C_&)a8one17?}1`v1b5;8-$LG5|Pqek*{-Eaq|a{9o~8$-K~Z=Q!(4&ae0 zArr!HD;c8CM~PBE?0d`k>mFSaGUXxf6V%RD#gKr(dbar9;_&pTo{5q7jJ1#9TSmj* zpvdgE@=b@njZPk^zWH7+*AjA8S(z>}=b^;cZlE5#lP3=9663v9;0o2S;P}1c)y+by zTdzL|=ZA&`WzVubyc}BRgTDTLRD<$1Fp9-&PErB5I6$l7!pu1)f1vLN-L=D-vp*G( zYC#%G%+-x>-e+(5k6RcA9E({;Gp6%IZj)TcH0Q8IBEi^%|E!2@U9~cj+d%-R}vf+85XSZC2k-DBm`3hJSh?QBfPg zfhY?++a^)H?%5z%A*F$keB;~oxT;OF@h+=PW9_=n-wn<<*d1fq<(Mc%JGkcp@=Wx9 zcXxmrE>aYz_oF9o+ydBRyf%5a6CTr%4irkzxxvc+z8EBMw=Tj!6D&&|(3bRW(ebHe zvP3*XZ(SPhPL5GV&GWu&`y;pJLyKlWW8c@D2{#IMj4j=~WndUThV2XmX|VS5$t&kt zR&V808NRPt$QyOG)2{z07aKI~y5lWp{x8f#8B_+i1NIyZ$;X7G$OC+BKvI_9M$-Zz z!p-~SFPDMY2#9NDo4*tIhcXxeP%r4!D6nW26+uUA09L5AU8E4iY@mo`Wd~4lxmvW@ zmu=9d7To%Cp3W#uu7Mn~MAnv}@Nw5Y-mO$V4usBbVjNGN`3-RrI~FoNRwSPPvTbx^ zfA{~V>OBCG+TTB5+j`9_hKhOb)k~IWnxtvdal?^`BW<`6uQ+m*4J{PITj9jg$|SWk zDXdI0XQiO!$doLxTn%%iIdg$4u=hFC@BP0ow@U=)e8=;B#^)K|@A)Amv%N8Da^~p| zssHBcmp&?nKn>(<3VBxHfAuJng2UlVA~@h+W&^f}xBdle1%t}>UCNp+9W%C;y*v#_ zqZbM7FIz_Ftfs{>))LHHho>pDgc>y{dEhd8Jj=Lkr1+j=ZSf1rigB;ACabP#nf3gT zYAEQfLjF1)g^g05Z#k#lKjZOzP4ZVt;3dz#S+mPOq?9_rtC?HV7kR@lGT3b^Y;Jk_ zan$ug;}PGuss-Cfr@%FHir6D7_$%>9u1 zA@x!_>W@Wg(p_~?)#UsovwqFUyRVZ{aSh}t;w1ym#>F*9%tVo|J?Dn5E^dj}+u2ea z4#aV>yyCqMc1OAdJ8jrfc*KjN>xyi0D|-Eo$b%|JLKDDrZ*d_QF?2(S6zwb!EU3(SnS#ONsFw>t2@l-mqL0e1BGjsdwics-3Q&}ZiRCK*MKQA^pf zt+WzSndewlOEK-vr0IF z_NzG2f!873r+562x&ZJn!6D`n1o%35x)j*zA3RE$A-TM$g}@&9g~^8+OQjg&G6bnZ zbOthZ6sY#6edmc354BfR(-H)ZZXMihw?#^G!43!0b$p;+b#Qn+cnnaz^>IITr-taR zQk^KXcE`)8zk3%C6eML7$7(%|n{qvExaG>$lTpgAfd*d|jnKV8&27rcYe^Zq{)%}q zP32%Y99;umO$~*Wpkuu5_5e*WU1 zcvjjS_E7r9570Nc)y2oh*%n&IYQS+)$#44>ch|i>F&&;XrJ&{$dEv`0ui6{Gla`;1 zT8m!9n)Ma;9XV{WzplS%(hWAsFzFChKGYfmqD+2KML?+V$tVV}SfgoI;8tgh)C zj%B7oF({;uU4V(J>b&`0z2e#VyutuD&WMXADv-k=;eVH%;Il*elp*Ncbrw;{eEBaG zNmEcbrTNnSb;lLl3-HY*uJ+)b#Yd@Rt&qPI5BtV-d>{B^@|p$ST7>sJURR;zZ^~M2 z7rjgnFg?-fn`#o`w=VX<`)SYn17aCaNhF1c98v*QSs8$z0S|Au=|J3+!dI61ODv$g zzAqXt%~O)F9X^mQ?!(nOBr?}(q5I5ZNFl^mF=81w(Fy8B_>i5uIKU0Egiu&2l!fYY z54~AUDH4y#Zc-WngK7eSGScH8QZa>OJfcZp0~Ve-i?i&x7FTG1)@U@(jEhBC=k z)HQ0$b!tH{E&Ey4()$xvdN(ZHw_(X#V~viyJ06co0c!OR)6L9vxhk=AUE{)D$ei== zR+D5H3%Q1;s+iTWgA)y!m@&f{qfiSh#7Fv#*amPSq!uIJoWX_v5uL zD67qm6g+qTTwZMHH$(c4mv6o-WW2BaA@y5wCUX!XdD5=7P8jTz!u31a%}*^~YG3kB z)fzU{pIp=y*#0qJTaT+oZl;k zecy5czKhCS+aj@ZevmISIzhpA1hyDLaiW3&PuEF-45!JxJgpf0^0WdJyjsM>!1HIf z|Gq4iB`gv@9u0C}392mBEqldhZZ|FH$YaIvTT2clyxFASkb{6f6e#ow3Ta&$A`HOY}7lN`yL@f2PUKS$By`Z|6Hmx0xZ8RcXnTu0o2FiMjdpB&}iDn!{_@=ciTE`T20AL zglhkom_l>Q-`C;)VyG0;O2qO+O5esHnz@`n4GoB8hw4o0MgG*1XP5OYjY z*7SThA;>#@`zgg00_U9!nZ*pHC3HSVY{Hdm=mflqo|tg6gY zHVGoa-gn=g5klSfL+aVRC6IMkz{@e`k)r`33KY*CwWN+j=!A_pgbfx=q*3xmIk*g6 zIHK^7Bf|Zc*Gl3Sj9tpcWyY{4X_`_bEaVtsS5quUT)bVf>sw|VrkmR<6Po_ovnHYL zNd8Tzd3Gc}P%F&KSI-~v?T1sK^0=^7 z?&VY(jhP@SftdVU{gPUw_N7$u&;#nHh)lF{k~Hi|rowJ^UK5g?6u=Q^59%UP-E@ow zS*6)5UROzhldvnvz13g9)hdKDBKV#$+z>$<`9%26A5w?%QhvYP_vdd^6OtMlAC@bC zBR)_i;UENUyf<)02gMb_dqq5cK~Oc`t#tr&2s1yAf;vhHOr!Z?7QgeAS9Y zpA(JI4c>?LwZXZ6YR(U*eZO(fTq|y*ltW;j3gCw))E@!1qneE4-35n8Yh7$fcjvms zF~#Uv2uAvgx4|x@5zEV=R-~OD-Qe&5_d_F_piEww5m;Mj=@n!dIQv5?tjcawNa3_U z6f5IKC_yp{BirV?Qb}%NXSPzxOaz`sds3(mOv``YAm_D^iN`c1uU-O4Y^stusD&X$K__Pqbv{ zxNzE(67W(PD)*;G?YQeq;TK7E|vpaqxrY9?YUJe#x1?{4Q9#}8Fl@u{qqd>^ zh!9!gTCiLOwUci8NqZ7@LaA_xA$}rV(T|9L4D(bPN$2n z(sxXbwFT@Mq;PUv7Fvhk)e5vG6MQx&_(`Zb-)uDR;|b&D>NY zdaWxhLy-ZoZe`c?hDN2#+jwOhlnaCU=?v$p-OJa2velDxtcM^cW7 z%1xOu3S_ev2VkGvS+8EG@vfmboS9R9Sm;(2Sl9cAiu=f#1m_so@!Q-M?64;T z-J0UuP03d-a}6h}%y}CR116FqPfR?TsUnLnDvgmvt=Hy4 z-f<0`OUEch0$ZrU;2>Cgmkfw1<%-&Vd{}gakQ5xTskx3lFhhI%0CUdR`M#OQO-4&u zUV9HIf&aY#HsFN)km`1&lG@;m4>(%__;}5Kz4|ia;0!<{S^S3YlGk>P?UnsKXdBG% zdgfX(&$Vb`niPGzb8(}B?}B;{=&NNlO@rLWLj~2`GS8g4b+wZnPUza^#%ef#)FG(t zw?^2Ftz!i#Z`LG@PE=wJdaEVot>aY-JadYQ3eDlPm-n3o)v!b(mNa}Gp6^!hGR?PN zp9pDMWq?R`hu!!P-i(IBb#x1k%K7m=1&e3dNiDT-fRD~hd#+euQXsQvGlM?}M}p#y zWOQ0XhWR3d^kiFJa<&zlyJq`|<>iC^;3rvD2=Y3k;`2Q72e|lVNahX}TPo!TX68qI z(QVIOx>48sWLZ5i{y#Iw$j_J z2I4Z$qG=LOq+{r4DIYdiK!9EU`X(w669x+l>%oW6MUjA-kN+s}Cpu@S_Z6DJ`Bw_G zoR}&(|JWHgf`UkT|0%-r{vxC8ao(o(T!8t*fVC$|IqTs5iA>#Mk&Y63jA{Z`)+su( z0|Crb3k<~9Mp%WeQS+xgi)ITf7nh5pd}+HHeS1<7fzbKn8y`R94LlgZMTw0P)bMz> z7NNtDA$NnvoUX@ggqQ28A`l0))yfB$|v{t6SidZ+|T2SY^NPN%33k{iD!cJFJtri`e?{#?rhd`fdNzg5%79315dtFvkS3CnmMvR@g41<;4Gb`sZT4$O zUhC4~0N6C85#Fkk>pMDZOXPEExif$j2koW@+c* znw*gh&(FD@1ZJX^wsIBRCwjGd z^{VcuEzr)hXS9`?>p$3NIvS+Bv}H%bAW|xOf=r!|QLxodkHN4!;!|wlFGqd-Z~ifw z>n8Q#wR!Vq%z&hYMRQT?y!uOIK$k^H17@!l{h&qc*1KiQ^WT-GV06$V=bhv)l zNraprLQAZ`Pzx;(=zSxtA}xtY)6*8xR*al z%0c>j{ayC!kd4!5<-#}Q(%JjOx^TQ3D$8_slllw%fhSq6XVIT&I~Q^#qwA<5EV@QI z&F^#?MXnarA+2|7KKPPZcYDEiJT=L3>Xh&70rn>wPb;ptHS+ds61igrZ&4`|X*_d) z-OF(f(?0XR$#zCKcjFqWkK2!QJW*qun^jJ-Y$44@_Ki0oW0ee;By0^mQj`IU2Xs4` zQi10H4a>tkOFUMLLT5v2b+`GE#zU19BWip zsT%DwW{3Z6-py%*nA^gn5BgoxWci%vv+|y>whM8R!^v z#B!hnj0p76k~#TjAa_eAvD=3vl9HH6Z-m}vHq!-H&qq@E!Bpk<&`bF^`!k|QR8&;t zpDlWe-VFRJ5q62Rn`nbF!-lV2EBlfafh$@l9aig~EP>fm1BlOIn)@}@rLd^kTM^=4 zSHaGyBq2?_TD_l6G}^POPe-+$WYFb-!=p zp~Xq0ze-Gi@uVqMWJ{Z)*T8&K)DeZM{vXsXo4ty<+&}+(?s_u4tCWpb!Z=1fQ+GW9 zT+qgJ1AUFmQPGyIl?lmR0xJD~^q87ZKX>lj*ZHJr^#MdD5l}Z_m2M*U9<9JDA@T() zXJ7!sf0f|Gv|hiS?7iA{Pj5ISsrG`E#w2n#yy9W;Pk0<^bP`}hON6QQEdF45C>yP9 z@e0(JpP!!(eqG8WS^0rgI2QQmZ+`r*7jSh*2JpoQv9YRqGccQdSXsd7pDe??7!=CZ zx}F9q4U`~$OZ_X`94qfBgFp0M#Mybp$BFjd!L9~n3Tzj2>j_4Lo!<1Oq!d`imJK%Q z^7X3Sv&RC!rAL9R@Cj$sTcK_H z3SPf-uLoKW7(&`E@z=QHM7Fl!%5^`a)=-t}pPn%FtsMR-a%`NkNZ0*np(~Tg3%#+_*QrH6$ zYeef8VB`>$A`xU??Qpe5$;doL_NECSHH*~Osb~xEKupY#xNr7$~SjgIUo^JWZ4Vxxj79AL1w;r!X z-Bk5Z?k^MKU)dAOsd19EemZ36gInI4;kE6dW#x=BPjAmte=(~sBPW@zFKIQs8kM2k zK_(o%@gP17nGL%a8OQA1TQ{0P4LbOhP*Xd8s$4^)MTDKD34x{Q8}e|LC-kO-j6GeR zm^1cU<3J;uOTduijaOS6B))#pPC@3mjnm}A4WHTg+{*JQRlhyK=pr5e1P{;P6_vGs z88CYzPMW?jxmh2Bv~Q=@pRaxT;f6ux3;ab^OR&Rvpn(xx^T};qE!o|!&c&P}9$Kn4I44wFzDYZ@_5V+Y0&z|QSVVYdKo z1BGeT2pwq?CEONsjIP;1Kz}>*wTrDyX&WSXF3DftgI7Hn`+(zBEBT^=Av^IZjMB#4LS^`Z9hgg`;!w6HF{d zV-hHBc3lLPmVkCI1C$Ie#g{LE$W;?@gy77Z)0-X~_Gzc2I{mrz;o7&6S)hGJTA0Jg z3fw4g9rU#NwW6TLEE;j`{?itqCk+Yc2)@a&6xM*JZF!RAZGn8|m_tI!OV$)xul_B~ zkS0yTEe0V?gu1Pp2C6M6wWe47BmT`74XQgL&mUQ3;L2XhHl}YI=%31Sr`2yo8nQ<< z_hYxLV`kep&SQL#j?CAfFNY4n+Ef`yKpmwZJ5ruJ>Zl(M#LG1GgQbJl&(*`P{u`9= zo?c)gO(BaP#%$V@bndvBIYn=z1J+N|5$;h0tA)I@iA89i_X3bnLl}$QJ9ak*7LVoz zt95Q+)w4N_l>~kMTz5^F!N(`J_+Xb%{x^7!DxuYXX1jD=^U6~yhQipLmW2V7tmT?l zBd{{>e=?EY$dn>mJB)VjTO{KO(-(Lug>wK5ZCa=U(4Zs|(Np%VU)|Lh{mMyIXGjMt z$IjMOrj&n5ijjx_=;j=@-h(d#1)Nz^->0MOZZ_U7D2)A?;`itVir$8PTX4l)J$#&w zQ~fw&FT}4vw+%kdZ>DQDW0@1<0Y$UJ9^pS==a4-~HUX@?tBF=->r?+Hn3K$F6V+%J2d0~ur!@9-RfEX+ z@&fF-dJFl6$&*C^i?y|lnojYIzz@XyuJRIgZ-ria9zccj&~nF5(|8Sa-fcq>>ZYd# zZ)(rj{12(Qa9Z$lRt;8P-vI0g)5g(YBA-`MS`iQiTp2%N()e+K*MVaxH{8)ozG-#; z>wHc)O8Od2t+@mIz<0gH3OAM2qsQWvzW<$S>YUhN^j4&a{bGa2)s|JC0g%6B+lU;NH_#FM3a^G;=}; zr%=+9v>9|KT_IC5J6^s$X7S+G^}hKK>`NQA~Up8=FMscGc@pvwb(eSgAWQi z7nK=5m>F}w~W}}EuM@&%U3tx55l~H!dPG|r?iRBjp)7U{Gl(jOtVp%riS^X zI`EJHLGgO;HZd%KZN{CLTu{L8NYS0AJx@tcG9GKdIFC+CJi`1Au@`-_YwCS6i?6Kh zuq#U8P#zCvgh2MmW3&HAWho#-<PMCpF0ntrr`zT4e>64mk_N zOW+oCQVu0Wevm1bL%Y}y&utjjURb=I^#wGman*vZr&yx~_U~Ucj(TZk_CC|}jKzX{ z%<+f5g(saRNHRrWH4*+iE1adlLt}Irvc9y@uF2NCfrs1Gh@vK{+$d3ufh74iZ)!zT zO0h}1CpM`s9dN&YniO`s4^aeX+AB#TuVA-B)a}_lW8Fh=Dj|e6Ph|Biswt?~*G479 z_sz{^-?2}GYtcTRc4A5+phxGf{1Wy|usCXGQoAT3{D%}{@eOZsk+!F2!7xevJ)gW54&dLN>o^j=*b5t!uLo@W607F2M+7Z*a6};x3%ZCn|WhQ*z4xVm+ zOi_wM>%%Ew(#bjBv2?5q*UUlMVK=biJ6OZHfNz>t_dYeV;S#>D_?DSW|77DN%!Xy5 zYd(1Qxqvhiu)VYBO?(QI_$kVz~d*P2!TuVU$Ek2@O!0QOxXH!Z9f!#vyc=1!&kg3Oq6 z1?cSO()IyUARG2ZHN!YHsCR+yFL2MSdp5f%>Ey>b%xYo5<6Upx z=RaoKkOGR16VSe$6wqxp9;6P!i7NM9Ivj3M#{!Qda5F99j~<@xaSo?OIL+Y0220NR z-tH)uZ#OL($6xV)V1O_+i9BfLxfPk0w7t^jstweu#Exi*C4(E=W zu6P%1QDEr>%euhpKWs6)WD{DT&zhhCF0;w`xtrG&?k-t2k#dJCY!fzXP$wyEJwr zVY~~XZyrq6;(hoG^PkX5oZWwaS5Pk|TsXdbsOp|4s^Sf&ytp3+x=EWjp;NW1J$Lc) z3H*PgbF<7tkp}>ZHq%E6qISX0XIBhY#kqeCqxOHKrG*`-v9~4!-!vNcWBQI%5qFOF zV0H_c95)jPX|~ZWpZ1cO(19>8nr-8GvNQt+3KpNkeLNwXx4`(QS0iLRHbICCzExLo zwn^itnL9P4ebbwhV{m^OmEA#mdJOUcI3zD1wF*)Kzg|dQU@2-1BnFVY0Cu^);_=-- z69Y?;#K4HzI#kSM7J$_i+9z{v?<-V|jeED>F|SS6uh=!OEzn3c!I5kP>gt}vB*6$A zE_j5GNrD%6!%thQ(c8gL{XJdrK~2LkkJ5BRV0N!+|3X%?XEqX}*}uRLniYy2hNE`V zVhX*D7;Epn3sgq5`5v%lpk+{Wp|dOXOc?0i^aPK$I-TLrqV26IAM6&;&jx7(^!moS zxOag@itp+YC4)j5^P<%Yp&v)uU4c>hMZepQ&?>YrMTkHbo@Ih3I|VV`5U_gC{s#o} z!??}&-l5omLb*f7ZoijigUs>GV3fK1AijC=JTg}E1zCX^9IX-rOyv$ z*clROn2azd`pR+pz2!%wjeDdC!569nu+qQ&7^Yk0*ag$EcY-!t>9hg5K^yy(HIR`R zsWuU65lT8ScS1J9WQ2gOb2YvCI`r;kXb|X!G>oDfrrWK@uA;XDNP2>I;-wT<;4-w4 zswDmi6P(w%$9dXv6D-^hsp@&SPa=6TDaidW7-&KB3aSNZP;NcA#z&+HN7>pZ*}avj z!+3q+k)0pKaBGH_L=VX!wD{E-dQM3Knu8&A+$WnmjqOJH7WzOCp zraI{$7ZyMquAH7@e{?n7(5qK1R6i}U!0yPFv;l7!5VWVfV~;p7`Dg1VWp92$~`*o?CWDu+k$ON3bjz@%_d2gi^TltyJd;;d@FFbLpd>{AK2 zc*k2HY(Od4DD;9k-MrRqS~H9+qTT^6<`eXkaOTvYPNwz-LBctV=q9ixE7xD zESwNb*F1isBBf&kV3S`bOmwh1xPv#tl?+th7 zWlIx$rXZyOx<+;_?5{RTuS;}E(A0D+g7H$a;nwXv+wKt1H6BmEK4^cf`W@JKOSlOP zbqiJ7PSRJ9vc9)bdXr!AzCuNCH;{Cm%neB1JZu?=lzmefs*1!$Q1nJri!n&ajfiN8 zK3R}eDP$K`jLW`UKZ45+R2VyuqEjMoKD`QJKKsUMu6vd{3Ajnsd#AcH=*G4HD2z9_&f^#>i=;CBTXh=h}_L{~9=hY4_TqtfN5d&HPld z?-p5NTeIv~fe|0k(Sr7XNZYBqHphUb0ftF3cPQ4NoD2!R2GP+*vI_SWlU<-Ecjc|R zet-J?Nq!Loipdfbd$-5hHa4D|QuVv&?pwGQ8UGz15~3fBHL8Dp*nPchYtVV|>g@@* zE5~c%T%zM7BvaM^YO}vky`%|#-(^cG*Umc>N*dU5;cq^oUR13Tt!v`~u<^cks-tbS ztYZ}PWj6*I$)c{O*;%oeJ2jmyrZafE6xpMm(X{=edfN%Ab{e2p&$)i7%)@TaIdw{+Kh>7aU$5HeC0a2r zy960Ry0vZg$~e0cV2ankPWM0poKm>`osgKW!U{3=N2CMP(7SKB$V1x3_U}iaM3I>z zRFL5++9D!@L_(RB6$}tyVsk}-o#3k#EVO|{&HlVndOdPItp626z@T~F2U6d3*4{JN z|NR1-hrWc041J1ZMTzYm>~Ga5`Uu#A)uVRF#F%40)iMN7L$!(NXCt7AgA)$-W}tVZ zJ>-pf?Tm8W2N+dG@8O`bas~vModiRYA1MVM>->su4wa+Qs!=zBo|HfSboL17I3|EW z$PMCu8^f;wb&X^z#~&66;iehfiUF7!tDEaP47#`dblBa8-`|`XavCUtghDcXjb_6Q z+(l`76}aWw!=f4W@NZ|=79G#K+Mm$_3V(7Rghxg?&VGG5n;Ou6x@DmF#yqk)c zpV}+Sbcbw6T5zXC{{%hZ#(t!#IoxZ6dFVB29+r$*EAvcX*LU8jDdq|4W+0t?hF;@V zQpDjQ2((oM{F-tKi`;aK`;u_nVZ#~BGt;Xdrz^CHWy~;$!F&yW`#y7TKk@V7q?aCb z6I)obrd*gTb3^$tdPgxqdGA+fgB#xjYf{U`2c}dM6fMY~`uenG6q$D97N6H>ohxK? zH}~4Rv((oW4DSZ2{OzsWqgyn?t=%eAHO8x&7FngHw3_F0Ch9~L;;lYK&<~L5?Md| zkZ8DYoZg8{u=nOY0=Os7NyS5^TDDosKF$RIE|DMxP)-s+qP%5ap)9IUH98K#5eb@( z#zQtZzI)cvUfOavm9t<>R>0_v$;=MpZrUc0`%CAjNm#12q1j_ z6h@6t<+A&#p@r>tEeGbZ6eWcv{%K7G-fAH`y=q~$heB-~HU?^4M@Fvr4!Q4LAc)Z6 z`!I(4Hl%3nvjJZ#an0eCxHrEtb}M6I;&wxz1HmKyga*GN+u)pRvXMl&!krKp`zeGe zoc1!V<=|^=;O!($UY!im04NL#tOVRyPb9}&-F>UsUv1gmJ1(}{t!+~se6`@I7P9CM zK-p80Odd0a$vvw*REevd;ZIkiqY*QRXo)@amH;({9yPQC7J(MHu=^Hhfi(D&Els?{ z-05flECsw!#$7S^@iV$NQhpp*7;`8E*$$xC#S-QX-LFHy>`%r((4HOKzoR{z!oWS_?y28qcQyX&Ruc$Oe7tYL zyF&FFX^_*ras)w{2ym0!C)4h+fUw6&K*7?4h=R-CsA{uUyXKC4f!-iEocX1QxV{+q z4QBO{fJV$E>ZVbjUd!An9@y6Ul*Xe}wd3^9(!0IZH}+dhrD-~v2-tf5#9+AkSN1t-krTm9!GuvhGWCa&pLai>$3amc>O;RlYngSW>1id%o zE2O9lK!)!?-s?`9@uTZ&6fP)k)>k=s*#E`-g@4U#A;s{Tfl9N{)I@BpHcd69a)mZ+ z!+5yq+DcRmfSKJaS<&WR&@WZiw5a>%l2DU13t8_L?+VTCi<5?<7j7>&8YI@!>%kUp zH`V~di$-)2z!0$BB#xk+UWpZAx7l_#!~T`!j%4lm-q^3-)!&NrX|dpjfkS52ym&#p zVnM~sds^(D?rWu)Xj`{epRy;apWpcO#>KyN7(A%&59CqqsR8Z!~f1N9_tGS7GH%M6g@Hnq~u zczRHXeQIC%kmC8jYhE9{G3c5%n0bH=ba=h+pr%TB*7Qa{s8HOW$W=FV&c}Zx7J+)1 zAF1_RhS&yeD*Ca^b9qtY&vw!XvN4F{>T$*&f)fdr|ND3hVkbSAPmxg|iB~ZF{~HpI znBK??d(DjY`Ob@<&|}RW<00{78>fDFA}fvzS=X1p#-G7I^H7IJ9k~>o_Ap=jEVJ@U z*8%n~L=FA)xMThVFYuG}?ypE-qX#KcAQq)mpgSYOUQW3hGrc1JY6OKO1JYAS)+Sbn zF-t9AO6cHj_alZq2uL7Lfi?eDp~vf}tob+?+~GG#<_Ho*tT0&>L$>OV*;c<&NveIOm#$UhA9K}u zLgE$}+UD%bxEqMd$cAy=RQjsdBFtLd^i}5SC(A_98 zb_NrRtpAv8LGG-{BcFyuZ?zZ3kI1oo3t7w&+wHj+cj?R*#+j!=-_N{R1DtrgKqi=q zIpH%!y8U^ZNwWV1l@~^t@@?v|qcqR_%|E0DobN|7ad9p&Q{D{&4fWgao`X=5mV?|; zIxg&piSx4=PL8d&nw?LZZPm~PA;qC)F$+mS1tyw7!cZnYYr$+HA-W*03(_aoGF$&aJyeM@Q`Uj#j!} zZS-riLj`FjT4%v7dVy%NW(u?fgzgEOX)m8IXslenP!ddmco;;Vo>p$V@fzJi$I5*0 zu)Nw!`iR{ruNiyQq9MCSO@Sf84D#m};UOj7t49A7)5o1vI`4x(+;${h?Yr@aj=N~A z^!BHf#8u9b_Ty5TSaNbGfAFz%HTGFy>8I!MHq|>5`&Wlkuhk8|2CM90sJr~BS z`K%hfD|4Mq0MgRrG%si0-pg2$<5Tqfk~;Gn&GYdbzQgnWeHnquD=Xa$qb)8~yS-t) zR;-kY`^4AcwM9qieI9GC&9(Eu`Szy($N`rQm>(z4n~9yljIUM~VxyYVVuiLY{6*8P z-IMYtcvO!{=7D;K82m%>3thxflvS{C5_~QxiX`4D3ddiB%A~@6X}bc=m^kD04Y%dz z0@VlK48^OM4b>)^2}@{E!p~wevjtnTBEOPABYA~;?=JecB@G$}T(5F5>sX8_>@`v; zOj6S7v?IL0H@h?eY&BBMx$O*(Ou@?ZLy$nTA>-rIfrcsksg8ylpH{}wVc-;NNUvU~ zxl#+H&Q}-PsYH#MeRo)V7d4{+&y!FW8~%_Q#C$XBl%LV3#o$}i-z~z%ond3Y+xsQ~ zI0v5pITP^Rv&rDK0-l9JDwNoF5X^ILUrrD90yn?v;Rhh&ljHMZzP@OXJ~9SABj)v@-bHAOwlJF*2Z5 zfA#ed>D>dMLqD?IMrdp)rR0m z#<_2#b@OTE#|cMP6{+r_BgPleE;;FPE3f?2{1@Oc7Bb)~kpXomvbDn>@=_#GBv5SH z;KkA4RMJl?<1-p1!A1yV{6vcXOdt_QB!mcVHqzwZMXotm1BoR=H-05HRwQlsf=|2A zEKw6bho8n-4+=T}33W1T7;f78x=U zg#D%O2x!A1cW|G;8AQTSEh$xND*YhJakBbEQ!>;vKuieyYvgM97Xow4Vb;f6kaRGD zfFTzo`fZ*t4+Sd>RG&u&m6P5D`9gkjiPX2>E?g;OjVObmy;&< z44qSX*T~#R;xrs5gi30=vD>PTvqm!lET5kEyh0L$!D>?>P49o&GFh{YlJgKw@+tQ|_Mop!lZ2-q%y=iTviV32T< zfG#WMjBqOB0idNP+SWGiS72yHeIufcihp0n%nXJ^Dij2~A8KKiRbFABCRblDhp5oy z9_$u-K)5y}qpJ-OThdQFEE>b#0i1eu?J5vfLxK-%@c`H8RJZ5qQBv)~3k01Zyn6)7 zkhqZ=-5%^VPvV(RO(=@BZB8Sk1;#vO5jOco%3Yu~Kv*z4f2jYI=e}~rSdJYqI>IPb ztE3%PgnG$L;+tTtFIZ@PnQ~aacr6t3;*G%=U2P2-ithf9wlDqa`KK5OpZQbYE`+_R z+_7-chrb=fia7wx0uh$UkXGQ6Cqt(^bt`0hzvfFD8rlh1^X$$lWif>yhmO#ud7Wm~ znUPlm@0x}qAAOTASg2~YUTKJAjo}%YUsN?4O5x+DckH=s-(KYirx;JlOc);lWqGP1 zybd$L9gJjsYk_bD?cym@e}^;@VJ09l`qg48D${0GJM!SG#mnK0j&Q!&+EZ^>nPI}N zccO#MQU7pPj8-49?BSoPM$zZv2oXA6mXmlpQIQZ+3?ceU(C#4w%#rp^T?I5(ECca? z6DQ5Ckgm-2m-R#9sTZ{9 zCbKQ>>T&RZA-sam9Oik`)ody=VS)oRqBg@69M(vDxk#NsNIjhU^4RS6)6OZCR#ZTU zr@}YE6*40Q+L2cws4^dfyYhurG{tOqoiKeYC>4=^$W@_k3j6UXXI1e#PMI)HeSB;> zHN|W+#XaNnzky=c(hxfCXgIN7eYGlXDJ^i!gb_c(OsPDCx`97GkJK%aP&cmL2Qb-~ zWiYpPJ6cc>vp{_9xoxZcj^WS0Az@C!QPRoz`YR1%Y1I)U)!-F%aQdf^aH_~Fus z#k6Sai7;2WAbd;aZ#8c(;XJrSyKpnDn?Ia6I`c$YN&2yjg=qP3!tt9*d6t_y-|0)= zgeQx+IjsKA@Ibk6<@O7V#O0A8L25&n}$w((?%lq`~q#4|e|h@T>dipW_~Hzo!mm zbvoOgI200HO^)wyI$Av55Om%4{zeO~O-4kpx|zD{)Xb}xXB}=16HAJt=Qo^c$y!SI z>$K7LHI^9kgj8fwNc<@6rFXYfg#5R2>YqnFzb{n}e!I>x*WvJ3j_Q%OHaTH84=U{! zEe{oK8JHW&+UER2YNfbR>h$*|uvPw}SE%2!=6vN`1x@-U3NhbXR#tB+ay)d-{g?EBB0UPqIBq_dO?FY7(>Ouvz)8(^s+YQtgU^|MB^6>CltO8TZk(3M~%wTZ$$L zraps8wtv0t$xAb}UN&Zqv2e`Du?TynK?;uBr6O`%X}RpZLt49UyB}(@2)icXul-&$ zsJXD=6B?JuJ7!0HoI-44&@k_bjOr;Al&Y{pv%b5PgCTmojjO$_%F)~cEe}= zU0oAnebqfSpq4Ef?(t%;oLt=#){lz47_X9OmA@N%`+WZ%`F`E_7xjM+jZOR~Zq_(& z(mc8Kh5Xv;?Ijr(?jO>OSln#78YzX_QE%b) zVSnqNlL1>BxFw=b;<9-g_e(*;`HqqCWewtvest9~&WEvjhvEx2Zn6r>+{v9gPCL)= z47^;57qfP#$C}WB4!`g^H($J3OgrJ3b(+a`v$gu;_0!oC6_pYD{W~9i__QH-lx8ts zUbiIcTke?|+xVNU2Y2kMJ!SKkqo#eFMT+$o!NG@t!}(YxL9WGsYVDS}r5g{Z+O1u@ z7r}B9pZag_?EAY1ntC5-e*X05C;5g=noVu{#=o_EyZPrww9Nb}%eK(R+7F#8Wv5hG zo1Jg)&ott`oX$8gbI^crg=RIZ#tytZ);>FZ(uAmJY>;s6#o^)S(v*Z-$7u6g!rz|V z&Vwhg)xQ19P9>jGV7v3t@y2auqcJ6Psp@+Pbt6ohJP?;SiH+M(oe zAy|EhzVXc+HRuVIp^T*R<)>GnHPQUnIN)wsZP%{6A)UXo6xjNF* z=7jxAe(R<1@+zg_^U_KGp+wf!6I^}uj|Mp#>0yq?#c#jfQ~e=T)S6_qYhwgeFSp{4 zBX=R~I#Lil6xyr(S?OBw`{CS?Vb22vF^!F#V_{+Yi^?KMXPj?NelXFy_wZrC#BV>O z{$=!)MRYmC>xY!y{vT4gVV;7`RiGrbP?GJ8lG+8SrAwDCTLR?^pd)wx4cc+@xy#xA z6h7zoO#IS{OU$r>u(%6nURmVUud*eCepz2F%L={l_58%$kKX2&l@iITZ~lELap#^| zNB`X83T4}#&;G?)m!iR1vqpPxZk{w14e z&u~>_S>2bJh*Uj)z9ImKbAL|vIdXI3H*K+{~l`ok(IP>4(B-N z^L7n(W#MXbfxt7#%E^xa|c8%h`PwG#u zpN_+?q_-r7On4t*RsJhpt{5iP$R2dTJmtVv5n2pF1qv3HllJxb)6Gw%!rDqq&wBn!&KLAY867i{r~;z^Zh)$ z->>)Up&Ybrp=!5sYoVJiX4*@ZXVUJ5?0W0K>vli2qHp&!R+ohOPd_1sP`dmpL`LYB zfZ+Wrrp`YOtc|HNTZt0uZ{Zh0j2o!?oejFNVQzOg!o7CzNbwgwZ8Ge!`U|BaJu&T#4w8 zMFD-2{akPOg&Mn(haE|G|3Y?Na(0pX;7k(;qKPwLU|8vJlcq_t`19tu-AHMzlw1** zhvay`Nt&`Eqv`*)1&P*5yrsPNiLN#*#)|qX-#ANG7o={yf5GKSh?z?0_2ab{y5gO2 znm+kI^DiHr>K)*039Khp^DLoZcJe0jn640RL01mJq-M$=yN*999v?5NP)T84+KKBM06cE50p9}M?QjP2YJp!;hh!_$>>-L_3{fYbiXFgVrYb$I;do43K2 zzpoqruqf(w(z)E&y$aTQ;4L4tu0>s5KDl2Do2D~_`HOxFVIeq|AGK>vE5?HlHX*Fd z=NQt^|H4*pHdmcrC!LPd#>Hdzr7jPdbNl{{^K-o$%YN^MvNmLOfz% z{-mbY5z~2XLf7r@n!+tz-Dt~3!r8lFnXikd170Sz5BdaXV*Jx8QQ!)_Vz#F}udfusc3M z2F^cX%)cyz6EnI({&VO~ije--wR6rcn9*_Z*?iWJ%Kh6{HaR7< z-dfgrq|V^_mIju*7L!H}V4avTwUwTBo@b4GA6%%0J2>O%BL zO41D?*u45oNKJ+{FxZrET~DS;kbFqaXX4*cx36vr%jG~*`LPM(DR5~kdxHA5A;=Rf zPZ&|9nrK{BvIzw^O6a5F0n`TWhXOjQFZ`m}6Qh0T>47Z~G3mP8WnU9P$bX0VY$C{n zz3W&S=;2cX{{&TQnI|`5(%Dt<+Dihn$VBF4Gp7qkr$70}_}8vF+zd5v-1KOavyD$e z=-Y91OR^Deva01?{MbrsmD}bw-^gFA^wOT3Wp&BQ&cd&hg}OsCE1H z|5YSm@{6bN*A^+9AdyPE=z7&qr6B*vj6SLt zl@yu9rkOw~v5>Tj%Td%6W}>*&EsThHYq=5KK_kP1GDc#Oi4n=HYBo4QUn}Ku5}xtFMwZ^Nd2eHh^pm*{)+I zV#@S4cQDj}IT$afWj}tQX;F<7KU_i&y8hEQ@W^QqlK~l9bm{zD_8c*GsIb2|%=pD} zz*KkgDxq4r%eeddx|j2X4tk{Rojk_vd~@3zs#P*m?ET?7kG@&`khuM+LUTN5VSsu2tz;gCS;Y%qb^2WZ)f}&Ycf=R3Vm)WpJ=&nk_P2Yg9sto03 zm*upCKe5TLL@lLmGjF)9Cqyd8lrf?>H^NcUS%z*RyL#5PKyzulho;v}*q!9iFc;Gl zbvu2eG&+ubw5zo}y&iLiXK%mddT)}mpPhgzVo_5#K&4h zH_+tAO}ieWtIoxmgj*$yriU(W+D0qUZ9jN{!6HicM;fU6jU7epDG}10#pxik5tHzm)&KPE%pLmb#z$jc9Nsf0mxl`S z3yBxHT)wZv?MeYr!uW>@xA}eUf&Fkkv{1f`m!IvlAhr_ELSTgbNBes(+(dh{u>9=4m0-uGu3DJwb&Iq@p>9 zmpX#<*9EXl4j8>&__R`FJuAZU4b)HFUzZUA_u?pzXezBPt-N$TTjkB7w@M$LCFE$f zQRCAqH!u$2HffsKo2;WG*ieA2Bq$%o24zhCY7gS`XNlF&gD^YN#H{Lb@q}81HD>7 zwzo|yx54&e6HYjSyv)mvBWLt~{dH6_*W)Y4AtafHddYC^)Z1EhJQa@-f=EF^f>~XQ z=}kD&tRH;s;uI|tj*_aU6c|yQb)1PAM~oQcn+Ci24DE|bn)f`CkICbTTUKPbOk8DE zfpwfQfvzJqLTLY#1Sz_haG6k!%kD}rNctzp{Q4QTJW`&`B3waopffdRv;>UQ9y&gY4x)B1A9x>gn{w0@B=Ebo=5SO@!;hDy2z?5K4CCeZll|Vn`rOe#GA>9jXLuh(dFM$0(>rpH8j@ZZ&aU45z7Dh6&}e7~y=bl~zYXcS`_`gd zw`I6mvPmjFX7nuI(Ez((2_jp{R_s+oTwpRHxzNJeZN2km@U-Qh21zFMmNv7&D4U|j z&iURfdD#dq?42%~V9n0J=iiE$=%3&P)Uv5e$@!R3+Tcp!>}Iq+$w-^qMJnab5y075 z)95Axn5}h-3lbP$#3P>B7@$gj*>(EYt@D05uYvK>Qht(rz%AB_VA9Ws<|g2tC%D-1 znDu+;1=1`DD~w1G0WB<8Yn7+B5g|RuMx4ZZs67!hfg#A~i67jKEnx{UTicPQOYAJ* z?6#tI*O*?T4|GK1K}wCJ;eubojl-(pZWqYIr-3e64<~HuhA@4q()BN?i=*23Tj76M z{Re@3iSmiRb~qdkyY|E9TJ}7|{2hFNnl-@t+-G!F5R)sTd0sN6R6Q@2Zyb^4YUVeg z7re5fE}!$!lh>vzUvcCA0$S`0Bc7RP1?XJ27F zZWNGeWu#_TuyY>ApuHCV)4^*Kn>u~b-`7FKWy3$YH=0F9Re2d{^nDJ?fYb;$70XUj zs+W3sIrL9H2#T7U_^E@5mAapc zZLq*Sr{ktH`930z4U6EKdwes;LSRO`n#F&lc= zU+r;J^jjYUZx22R-xR33_{y5Cd#~2_X#_Bt2x{ybFsqZ~Xro)Pugr#C+-2|~z02rF z=6Qh(BGN<#Wyd^PlGa+cfFn%?g~GBnaWGJ8XAWsj_H?|!Swp=DBfUHzP72#|q_wIp z@GDE*W!H6B#g@Fq!i(?xSIL3d<5Mx+3{EN6R1@;ZVOwZ%xu zaEiCpiUXO^7X47;qE6xxc5-{nV{6x+z&jBm^6vG^zhIXAAsZ4UF~_bY89g1rXS7!> z5+M3Ahx-kdIiq9xnY@{($y!fELBjuxg`n?!NXh=4-~jmhszJb#%e^jElcAYU4jGYP zZOh9pF~n~THUSBO1IISBx3-@uv$6){JYr|b2CIleDg%yZXl$cNlt1>XYe)tu6@AH+ zO+-Zd0Li$Geo!u{&<2RX0q7ESGg=a;NZAIfV+PmOg)kB!vR3vy!DyqIQ7-)|M_M0@ zo61=|W2L;ZVzE_Jca{AK=<9j}9I>I;K%wMqf1ZW;z)mv4tVJpAXB}d|0@^cH>M zY`tD2`kQ3UrZK0oDWu6x+`Rhw{!eBQa%<^I>%CGgyWH+aVff!?lB?#y^)TXG)Ly?} z6X|{y{e3}49d0>?4t-~&?m8ozv0Lx zrGq^(&gSK8=+WZ&J58mAm7URCre7JlKQd>+nHxPjpRj$&_ICgVLWwoiai9$-Gai$% z=v@=InFd;_I~TTr5p#-}N*X?~6?`ovhT%s!1c# zGGme(nAx1b8kCXh;I=a*@>yU1T9o`Yb%Igja;#Hm-uy?A~48&9| zZYw!N_pml1I&;^H$lkx)h#aAN&kJaz;Rk?mQFFq6?n!{HEJC%B$yG6mzz^Y}cMf-& z+lwxXN?Q61yc5f-|KYNam_<7V!^UOFTkFQP%RU8}mGoM`P*uI1I)|jm)V7-8vLCB( zI1!^F{Jq6N$%DRdTa0T|>`Wf`gk|`bD$3Wb6&SGaN>C6MB-pSN$b)GNlkIiZy?V_?Hy_0$@#6)jCRqKbC_a z;eWF?(;_5}w#d?X^*k@?udb)z??1Qst=I;eDeW{po?C4?O53;vUTE39uo~Z!(;G|k z+9Tw%HC_=W{nOMRYjAvkohgfKGZQt&)|4xJx2FkoY$aUkRkzGc%us&hMRt4>LTQh$ z!))t%2klfewkr`dFv(Ye3^lbzETT3F-vl5s_6FLzKxZ;pzP*V2!1O@xfn;v|;H-P} zu|$$aF@rmn(s_40!X^0)5?qcCT8Z8PEA*)QCJV=1b|-wT1iWepkv+MWsa;p0H4lhtmCFN9(p_KMO)1E@haLu z&~Z>iTwFN4w{v-;9{Q7Cw{zZXC-_l#>-r5W5q6Ej?+kbLOZcikrU;HtMV#dNFJdkU z`kU%?i)(6rN7cd~i^b2DZY-TC625yKv@7KZNNQ_U1GlJa-`|!?=`?^wRqMoI;Zx~x zR5dHzv?izl#DPgVahLq2Lmb}S!?#mqEiusA~tqfhSTWuk+Xa_gY!QSG@DY6 zvbiIJNPef{y8&KXg zwg%4vAsa|H=^Ram_@GAXy!U5|BgLJ!G!ww7L)Sv5q?Wk26-zGz@8=e&w8FsiNk7{U7`3UWzy^V-}FO^KGKg66PSO{#hLToRISYcVHy_?`O3U8Y}q z0d&0T(=%;om>h6xi9jW2V`quEt*wcM!BlK#d^P$meY`E%H4u*dQ=`!rPE_o#=sIr} zB-}g-=(Batag+LI5({mz&!}^9Uf~`)!R@Y3^W@`p^ z&Th?GhCPB-Dt6P?17%ygL|H?xvbUPrAuF zXXj__R#X-lwp|s$2S0bEJ^YM{^FIq-^C+HwryWkEvOUG#oY z+D-tTM(k)XkuL~*Q4zmkj}gI0Q=b&Xex5VtgL#efnBl{Iq5Q{NzQLr_mAB%s`IilN zQ^tvHHho6s%J|8S<;_6M`EK86kd&mZ%J#Gl%raeep$&J6+S;^%4VIXv+kRt}%tw^q z7JZ#HPle-)s0d(D0tK5m{P%%xqV)*||6o5CH=l1ZB)wm9z=eQgIcHFtgK}g zQ6c6y^`HvRdfN&-8dzC3=kUsDkVj=7LPeB(yDeCDp*TkknINwk$|VLTn`|TG-S}*_ z(j|7wg{jG#xXmPij+%i9r(@g0gsj9a-P+oCdB*s7llxQb_vUMXGMyNE#|aUG66jXiPVt z+p-+>dK$|i>CYj^uQSD3(cU0u44?|f=Y!#1^BX^IyPF49(Yy9o!{Nj?Taqd>~oHse~q8D28C+kr`4+iVHM;Q@CJW(@_(lFLvb8iR34Wyk9fEV z-j%akrDnyXkWM`z&l~*7Om{RZyEb0wJ&ESUqWhE69l;s4XwHzJh`$Rnr^|2B#^@5f zsk6gA^Rsu|K~-_TH9!dldnltWFwC}cwt6*?CO5FBne_dVcfYpA8nP!Swt}Zgu4q~x z^MHSk84JBESHd7FdLayvBm26$qU>4&N{0!@GgGp1mv^0Xo3v{VB30iOJgEHb+FQ6- zpMd6ib{mXWMcd^9GLuQlw2zi4{~*ge_Pmc8Cdn>{9m=tLm}`LH5)%gEM~)aB9==IO z=%@t}^~O_&czg%@H*C$ITouhf+vQ>~h`vlY4KcckeJ*@)AL)_USdMDXL|lMvHP0IF zwD=4qW0Ke<$F`jc&);ldl{bTgE-I#~x>7>J$BuPbh~LLMc1j$D35}4}Kq;roqZ3+3 znzfT@b6Ts-R0b36AILj*ZST0Xm6p}6Wyj*iAB9x(%fN7?ceczw23kD^92^!WcWE{G zT@-~xaAzCnbJ*j~K;$~8z9k$UQ z(@VP7#nyBZK&FW^O=PJLG#X>TVTG8Y&w74f?Onunc?J6CW{bn#4?0Tesm4Q2Fr-G` z)V30*&ad%QD$A0fpwZpN)myhYa8f(1E&@>z?S=IK+<3+HYBt3EO9+HGb4qOP-7&tL z5;fH+NP56=|0I>z@0ofAlfVW!WH#d{9?pDLR%m5U^T{O#kKhY8hY{bRXYHibj&--J zZCr>c9U8p_7@oI;NHOh>KM`xuDAGX7HLADMa1wCwRh&oAh#Fw5J!sZMLMJ_$ng17VkP2s!c4K>P z5pA#5* z0afq)67FfjS;R9% z1`KY?c)w5F5=_gqd)#(2#n0xGSDekKM0C%vvm?h6N*qK*@*K-m+L*nG;6sq)UbvJP zH8V5b!Qt8v%!AzICUOi!-f8qJklosHE|o;^GsrHq3glTAI$BxSc3x7lb7Q_W#qtFB zBUp(ZnAwZEyn-F9$L(~zncj24dILm-W0Gf&*%tjYb|-IKv+QxCR$BS$%N>Q$=QsJq z@9f`nc6KN5PPxZqrvt38%11{`^L_VOib%gqoxD^C_jJYEsnQ)sMerH29maTzfJLJf zqH9AjKpYC7thm=Tf|t#|b`uohu|1xR0**r0G=uH3?y9Qlv@+f6jN!PeEGFN)ZuLHt zx+m<>`74D$f&p|VL3@Y^9mtia8>ixb^c4K$BImXCpRZHoo2S~^33i_~Zz%VQC7hgy zVcfY|%C)FGD+mA#0CH%7c-&nQPcc%t3H-uHGu8iQqbONrMYW9)qx$&&dNL8xHOs~> ze^*d+wtV$t8q0)v^fC@N$e{9TgS zByj8+G+82H(a-GaI24)#)g!hE;BcU$Ya2RB!oA-ul3I$NXX92X$t<1J4y$Neb;T2Z z3L)(}Wf*CCl>KnHwVmwet?;KEuB-(#gtC0g+JNlLNnUE8rVvGMTWo(I_WFJ-xrAhoN!a*iR7h zT;jO`qSc^LHS|fO+nA1gekgjc`0V z!XJ*key8vt(x{jN4ORwfValFcg5|9v8Kh28>;`pemH^(`iBT60NyY$s-mwCGkA_3D zqwG}!_9Xg=O39sQX~9tU^BNv;RGWL#k1XV_nh5+9fyh!6vA{f+Kzkm*?;o5vFw0on zp1a^kXFd<$wyL`DJ9LLDN-e>vYrE*^k969FK$}<=Z6!e*hrR14CfV6J0Tez)G*=9K zXB?t#>Y1yT-x+O7ptTdo*24X*?Gv#SI~G|%TTkZcobpU%^3IK}FxZ3Yn~v27`m|7y z359gM8crmU=6ld{yNNV!4*#F54Q{O0v(=MacXJ~W zF!BMrY3LCi)2`(W8!210H;aPiMnfQyM=5wu`gLCn3aiuUDQnH-hrY`9xwxj4NKt z#6{sE_@>Qnu|WNA)J1s;j>7P$NTIlksNry!-kj%~4~g1cmSAr=m{20=Q5}Wi=paB# ziODX2k%Z4PJ{8v8G{RiJ6dpv{S@6JH7e!)ewqIoZN+t0%+kf4&j4aJ$XAJ3U0<+-2 z^&KEy%J4VVLi0NpE7ze&$)NoGUg=L}WvkND#> zix1A8#;14YrBfnE<0}J1;*7eeQ6$iGg3I&`-2O$db2%O#w-BMag2P7bIoV&=gT$TL z6+6?D1`<7#xC@e3ZCw-frSYf2v2(s+$Ls~GMsC*v)93BZY|a?sXfVtQ^YgrpjP7!E zrep53?IkQTO3MXQY6dLizs^PaCi4iPiFtCjo4Ka#i79${s5&W7k5s02``$l>8K2#V za`0u^(Jc^#8{R$uRJ5_OK zZylFNyT^gU&@52qhXQ@;ey9=fK`!w~?#y>z+4$*~tL~rBRptI^uhMT0#)Vl~`Bn2A z1?MF{KkP^LG~&T5sg@7^YI12C{DEads6mkN71J-kasq!(rU+?b)FIDw8auuXY4X~m zWsWU86#6oft*eo{Z%~ce)54F)oKp$c1YWTKo0+`z7zvI~*I{~=y#S-(oC-i8koFcT zxz;F3UWK{MqHvtHN$+Piz>U4zzz^?Caiz&UP^B|IvBJwZC1B#e5j-`SyNtv2e$Cx{ zcX5+c-id33yJ8$cp!6-0rZCq(R9Tu19wy7@l_iz@8^?oM5J&|khLw9(SS*BCbS2=9 zHzlW4)Ga)k4UltCx+C6lrlsZChPZedd*BWw`@wocg{405u*+h(0I*q^_D%l5hvg8q|DIlzQ0d6HS&Gd7hW{Wp03>@-$ps zwMQ+@imWu)A1)dYY5o-@GL;2`YwKa(*M$eX>G$+RK22KWkRc-fh z%L(Q1mO-!RTFu~XL*DHS*QQ9Gw0|StuYuaU3dcPk{b02ogBZ}V9&f)UegE^! zR1IyvA@YxzchAAArmcqC^6EpSSz7w-rofFO^0a?j&TQa6 zbaX$9d1&QA_WD5qL%eHc({#Efj;3nSuAN0j0mj(Kc>s4@BRiShZ{s@@$QhXVfb`=R z9ry@3v?qMnmmq3hK^Z5~2GvW8wB4USc@`-8AR&i{jNc77BW@~-B5{iy3l4jo5^cb; z(4`DX#eZwgg>h$;aS|YgX47d;?HW;YSwdZ0tDsXtr~UFY7Bq{R(H_P2-%ml31F>Pk z9#c@vyLv!y!G{hON;Oi58^?LsyNnri$k+{$gkUuXGWX@X^5p zl&k((=L{RjUL7lKXU*AS%0*WrBjw^uZW{sA6kE!gq5mnM&U{D^rknybHWfP$@d^|n z8g_)CjQOC7J(AM&>)m_jzOS>;(=rJ9^*D=f8CvA3=)MFR9KjjhL9BI~g_)2Z%8|yH z5Na}O-S>6TyMWWA$CzqeGFOZR56R^w1*ZC;WJgG;>pbBf zhyA(*i0+ip-|1(n)9*wL^zS0>{ZBym^{mT$CoTfK-&Y!*x zehF9WIA}2m{r6j2m(BTvK-_iJtC?_jviGOgoxer=@wW*sE_@eyv;tc2W;kh2CVo=`l!yIN@o<43JRPaCvL-QwPEgk^mc{BWY` zJtnGT{J_3`OYXJRtnno!Fb~%iKwhLP%nj@^y`L~RV2}vVr82;1NsOZ{qxW-~J@2z- ztt0whVsK8pQ?a5pU4EEAN;M@7iV)XdJVqS@=fECM6W=0AZRVoe*m{J-?J59+Yaf#b zx^<9YP|ii~4uT-+cy6dqBAx&xmgrdOUYI3KuABeIY3o>=(KOLSOY!s(PBI-84EO_F zw6IY!^Or-YJN}BnJ*I1&&q|`J%GxlIzk0|B$YX4 zZQvl(<-BWIe0VCzJ))w2_Hws;We~bReyc=mWZEYyMTM1Qo zxbpuu;rL+i+)K(!`=3x@Yi04yS0nxm+&}Z9-jeTX#D?E*yx|-Vmu5@SJMwRtb6mj) z)mC1k8Si&%DSxz`iMMh9J^=c<@XN08wexaGtt);ptwxx6dL9zKAf+Polhp!jm%m2~ zbo8AqT6wLqEI1XhYVBLhtzg?qld@iRRyB2e%<;ULeS^D1VJUQ#YsS0P&9)y{pj=m9 zXHU@MDhgA&8|Y%##&oZk;J;Sx2}kLfmbIJ_SC8CaNV3ed~Q-abn#^BCw z`jIu>@BWUAY))}R$d*-~(S`l7T%I;GT*FXmh6K-N#-B@uYIq4Uc?hq_f|*>EP5CWX z_OC5^sodY~Hl{)ZgKIxy&gdHP(iF^VW@`2!AZtRfN2krlXmwfaQ~u(vyKyGGy3RqN zyl=}M`a5eY2{4gAYi=O%dg%y))>Yp-1QH4_CdL$1fS_@<=(A}&S7spG&V!a;VEsBS z@*WFJYL7vr&)}5t5mb>iV19gIN30vKMbPCA*uO=#^O#?+oyf#s0@`tY6wiA!b53s? zwQa@ZW!@!Pfa05ADk@~V0CRdc{+MgjbFXSZuY&);w6ivgo8o{~^G#>yi0Es$sn zB^YX^BIl;K8!*(nGxKvnD;DR+IVcEuBs4CfghL-Bn+pz^L~At#P!>(Y%}_cM#jZF_ zb)JKH4Y=0+?rb6Wjg-{6D>+?D{*N!LjzKqnUzbqsKHUD(1xgu~Pr-a`iq<0eGz4X1 zaG-LGK40IEzCk_I^&1mU)E0C9LdH-y{cmPw=1+(8v0^hzW zr#g_s?mTN@x_OMKt4GBGW4h%W#Q!?F7?^}F#D3b0=0*{uvF^_Z$qZ-GOrOvd_^dw( zQXwD3O69t_NTrDcWEBijbMD?}1D%iA&fLwz8I|JzuE!VQ&3J2yp1fOfdzP#hh2U=2 zawTFaGI9TCCaQVT_Z0iSGQp<_;3QyeECQG2}G zhF~Gpz9@aBj3n2Q;`ItcZ7v1Bj5F0&lBZgPFR@Cm!GBMP3iSa4v_h}>zb=eLh`UDl zJl$T^$9ykCabI%^>$Phl5-!E=h;h=?oyDZ%Ggw2&{|cijsoTJxFA! zi&Zt*h2Ip8kZKyM&bmiA_H)-WD6AnBm2$jYYz_+NoAx({CYWeVW$B%?raa7oF87^1 z7;dN09#NuZZu3d0E^ziH16xzv+e6sJa`P%K>cUi2l`a6VuJ5V`o#mv%9YBfq_0}dd7g$#2Q4Lv4>T#U@$a??vIgdbak}onSjGRO)=>PFzh3i zmn6j{Vd|Em%l1Qj(kAfriS;D5sf8j}YMj zKG>+meQwjWihHLWz(jHSHKE8>8q;zsj~5mMgN3mRR}Ri1iiGqQ>@%n$Q9aDekD+XB zk49cy*|elDhUz|hnsV=HBfsS%QEM1+A<7T5hB5g2>c>=cIflM7v5G=`bpBi0VG1R- z$fSQ(FYQJ2GdUbY8kLq|?M+P@FV{+4|M#B4QH7rn`tKpE@==sr>&;h9)}DM_NJJs+ z`hkTm)DbZfxw!MF2M*0|N?!EW#~rJNhnA3T>M89=fL{9nxBJK6dukAl9c^~g?{&&y zv6hst^vKrcYKS}b|F-X{ou{2A5ec4S{(0>`<%4Tn^)g{C*m4a6D2ocQ6zdAG%P|!uTn+&dSo0xrV?j8Yuqdug+?qN`8XHr!^Bg|nItjilt zWjeB0%|Z-xaZsw@2HD>x-qX_rFLc!%eE>Uk!FFG$hMYQ=>JB!>t9kPxw#3GuuD~87 zrqRHET@BX6jd~z-J$4E`2T1&RxwWhAT=@5O=rSeJ3I~UZ4;8rv6W)}r1e5e^a^E<_ z0wwBWOZtq$~vk z7iYyV)BSj;N64J*KPknv)3m+A=r4&79YF zt2>8({s1xcijYySvk6bw1pk7xUz>84xAx8Gl9r6TBK|e=Ky(fN#HxrmSLPZmpZ?_fMMH)pRaF?Z#j zCOv&UT`wT@-~Sj@9M@X+>Djl&*~4DyvIj#Y7sI2Ng=59O1YM5K**P{H8|erLqyZOd zqZ|bZW+A>_L-McIQu$UsFIorSU`s2I9IF_NDe((PLUt_Hy?w#-to_7Ic-XoR>wL9j zWhEAqR0!kL%3qZZHn1PyihrJqR=+wOa=q@=aa?aXd5vGObKm0kbp~hEIwu68R2i3k z;GGI8m19RqP#sR7^~KGomwlg>`|lHUO(SxW5PcV`IJU|JT#h1O!sLDqx@xFDk(hAq zTN5vOF-Tk!?A8_TXInhJ zlK*4Jev^jKhscSCtP0JIigY8@`6ZVR^OddD`7xIqE9sfJTqQC*pxC3232nu+W7nHv?v9odZZ4_LZYY`N$g zhR0j6tlSI~T+sqZz|yw{l=9ORfCt8#vlCufJ3@P*Q@A70o6{<)F4did#T>e;@>m@l z)UdEFa0AeBzhDquM$Kq*M=hz2q0AHB7aPSE6Vrl&)Nz`?*goAN`oi0`KJ}n~?Dg;K zZlOhTJJK_U^pd7yx#@Z?1NzfH`q!+u>gl9|zHT~uq4O;yY1D)xgWePh$OABI7Abk0 zgS+Iibfm}-xmj?8I+wYU4`)-wxp7)eH8?LvS1?7WtdJrlfYK$-lf}c0|3MoRcf-#s zI{8p$3{}w?E+gP1Ox!y-TtQEq>4_nxqV>@k-k0@kV9`B$;*S+DlQ56L;EYJlx3*|~ zGptu}66dVxJ;6}x0T;8doy!sRrGHl)9RI#p^_p1nA)Ypd4|N|CKqVOyXn=zmK8>;m-kh&LlMlkBx&Pl-j`|iBFM< z|K>4&D}R!H)@#xyRwjEKhv*gU;+_%Lo!vTWFqM>qo^;*vA*CKk>Q8C5(TpzcW1);g z0rMbsavAzjh|pY$JKCO{pP-9&WjX>~nhc0=(|!EeuRxc3&YmV_Pm||@teaRb;)vnV z@Jd8grFVP^)5WuLMZQT`32*>M+#RP5vZ&|f*Vz%0UcKcwb^V@wYbFVUZIKVsU}|Y9 z;2M>t@E$dKC|9~5jjryLJuEIu6pGRk=V(^@SAZ0)y2jBF{pi%x`xD1{99Hbthy%v= z&w9W6$cJXL_e*Ioq-#E*@k~~D+4=flThFbwxV9}H0+u=ERO~rV^NSG`dcf|Ct)?2s zbBs9K?Q(xlTsVwHohM&Xlw)#!j@GtulwOOjjzp{LVlSUwWO;Qu@dupK{3`w69LM#< zYlafg(Q6jyIJEpj)l22SSeew3jCWCgDy`T4PqlHYwGs>`_J=RxBlKWtfdgEA#ol7- z->BnV-j5Laz*Zqp?`Xl)MYHb;#Ygq7`m(H6u5>^5N?zF1x#N5OghfDqv!MNC+`MLH z^m_vO$$pxL&&cW@$FOW@jxEf}CugX^*s526qxgUz)*R@^`He%1(5v$`xm_Qx56ypt zS-I!sOhB|dUCeQkL#}Ry9H;s8qicgd|9y9jPSnr#f;@3PfjW0urIl4oLCC>_XMYIs zdMr0#dF2%x;A#f?tNch2s`bQ+5NZ2oo19DrGvD^lH9kzpp}w8XBs;A}%jd-nc7HDZ zLn=F^%zS$1Tr}_a#nU%(TPY;~dP2u=nrYp*g5&B-G(DBBIUB-J;&d$@R+|9UGy15f z4OnN2bE!ec*}TS^{r9968DI}aAev6KN)u#C+V6E)W&7D`CWY|my{Hpc2k>b0*lsLp%s;!tvbo*mNHz}lCtVO zeJ4UwrN^e+_swU(11-bimnN#>L&CAEaZ7JFw}H)Smu&HaftN>8U-#+Cqssnz14wFi zj?}Krn(5)DdE4S|XH3jx)&JX!M$7I@E?RiA$%v|Ycxrmv@kY!VTIrtvV3QD&g%4q` zeztP^5~OGa3?(^`yVdX_^=@%#g4r9M+7MuTk`2$`KRKadoQ%JUMB|#I8TqM zqjtCwtu4U2LacS2uk8?jLa<&2eXXOgNyjUvv{Gi;tNs;GnrN%Jy3vJf z33T%5Mn{)v&iSJDsCIJ$F|jiC(D)^joRxU=)rN_O+Aac&`|r}Qn6V# zP>Jj`D%Nq^wvHc0H#3%9^rE$cNc9YTd9Zem^B~Gg+p^7UG$v>Bhai>EB_wk_V0+RO z3vBF*abl8dV2V19vfrAe?L|;d9XhsF&LdRhJ-pKm-@R&X&}bSpGl%VdU?V*U$^g~9 zG4_LWbl#x%y-MF33Iq?7OcXbS>cWffd~X}lORqkM7SSWMZ`$+IWfzQ2_876pNdm= zP^venb}F&=Eq!7zoA_r|1$js-t$i;=OKB87b)XNZFZ(wd=R_UMun`fud=UhOf?s1z8T$VCO3XQDi?xJeUQ#~*){9{d5&x2DHWTU; z-po?|QWgoXuQ(R_@=vZsI3|1k8reXgp9*p_$ol;7`?_@b{w1rSg~rE&@-Lh_MQv}V zZ|pf7p*osYOrHDg@Mo)=w^@hNztmfV0s@rzCgVA+-(mw=qloznBF z*b%X-uKJ3>hyOnn6%IEij~aW|HJ-JSduFV_L>uG`3Q<41-C=qb93rRw>NxhnDb{e| z`?_C7O@gt`RRViHkUk*$zOIWDI&A3@5wH8vYH`R^I{Dy}?#AVbFZG|{qidbOh-Ifi zy$Vkj@X_?wP%psMRlv39#ou5@y8D*U;s4MNyZukqr{6mf({(SOOjf;E{^2<+qJJah z*27}$>%!xD{Ac+7xA&MeIV3jBtWCcv0dfZMl3R~wLu%kfJ?Zy_(jV83yQR(5OI^-# zMJDv@-vfR0vb@ogTNd=UY2$=!Rd2S6WNf)6?Jd1vD z6nnbEpxvHG%Wxr3nk?$-o0jUn+~&$L2Oo~E4*NwZ2qJ<2Et zIZYz!mXSkxpyK7+MpF$sFaWLiYac^DG~M`aC2;qW!K+Pf@uDjhve0pq7squB?7u~L z;fiJC$8tlbGy083wy17hoFCJK<$vMle3jr2O0N#O>6hsI8~Z};A-mn-Hv><2**RPk z7i&xZQpe5z)bzBXMARzY-1kD8ijt8?ccsw!;B*Y#n+<)A=$x}fPxeI%#01HI3eEWB zB7R8zUNP+JcNvbvyU0a$iba>eN6MiIVDT?sLMnK5*{R|K1>bSCQXIT+_`)z*kKj7U;D*JFGCG~wkduea4t6{fb0U{E<5+uXx6gE zXSc#`SLKJSCx@134!W!fXwXBDhcke{vEOoH4r6vSE}Pt%Vt@jU#o$=sQ+hvUryO68~Xr6gULP}IfJ<-tk+n>EeO&XHoz zt&Yz?GHe6m{sB`TbNB{*4j_}#;T3aRFI8)29_MA;($OVX@vL#yZ+FMYJ%yP2u|G1at`v80ZfV{{1ku^Ims3N4`gUvE#xIPD zIi09QZxz9X%Xpjq66)TJUY#L6+Wv*!_i)*tzUAO3>X@RfYN0}2BcSbx7LjcCwz7*G z5V^Np zUdP|B{rvu@d*|SmcU$ZaYa^ zPAJugeA#B3ZARp#MB7L=D%3egy3uS#R7{=HIjW(X?bNBMby`Bd>-VpRf396OpZCq{ z^?ZR-mNs)1#Mjrkd3V~l-Yv^(409$TM1YXCTz6U4_A;7+>y0ydBW^k2L}L?GZ3}hD zx>^}7;@jG^LzBa8ry?$`Oe0m$C!vWO&k+`hu zV=L)9-1^{g3fAAYf2DTxpf-s7e!7INnp1BxHc$HL9+{79J6~k66H{N}i6)N`j0i**|}b1E!7lGxS_MtV2q>&zm{JvcH`OP0P*@6t01&OooVxeXG(&6<}Pr!~r1;#(6@4kdK3M z(Xv)a%qgx16stjWXh+>g`Ul`xTiY=LRx?g~Bz2#9j1zNMel>_=# znf}-#m~z~2gNxcNFkfH_nO!dg3p^NvS=YB>3eqo@r>{lyQ7HY&^Igpr{*Qv1ud02y zRHdFSw+(YgVAlX_j%C=qeby~hgwjjo;d2C`e^ehaZyjSSKAXjA8ynU1&N_z%!F~!; zi*+73e++G?C|oCPf~P-ui~4SlF&DoiFhTDNR8U%Xj;1}XK98N}H|@1Xh56tXNUGby z42|>+P+HEsQlC~?3W6kAUFz;YS11yihLdlPbh$kslr&XlmKxcG{q_{j{NAXLCY{w4?66~=mN*K+7R!ir7P|v!iHH5m#qD|)r1UX1k9~o_B?P||(U9Oj1Iv-`r(oBC@Uw*51W}a#i#4OC zzMK7L*oPb1>ae1|W||W>_#kQOxV1I6fqL%(q+V)??x6?3Iq4X$+ivz_(H80PYv?z0oQa}9tv*QN*u?p7T!oGjigvc_a#vuv`mm_h_ zJYqqgGr{zZ-`PfFgTF4XS{H63IXfP_-!4Jv>f9L3fWX1k#zT3ZfbUAB!E#moj^fy< zNuYL7{^u0tmghtgv?XI>e<2NI7981hT{FrB4A77u$J9$04pbse249vufcU>a^)CJl zlN(!IaRgsbj(Vyv)Y)#|j1)sF#Hcb4i%on6U1n7V{|{@|5SA~IRN$0xwBC|xG@LmN zjUfm)%wl0I*QeimR47sMpPG3b_S4spWNCJv39wfJVWQX&Z35~~;#?q}JCo=U9E@i^ z6ea)~nnN3v7I-5$VHKcxt+<@g@h3tv_IRw!?$f9U9Yu5I>s&0$6UfrW4H6FVG0)jA~fi8!_tS&m{w^oC}5d=%+&7Sgem*^us?}s zEY9;jv_%ObqB=MUK;foc$;<@KH9A^=2ZWJ=P=^~)WjqN7T4#T)xlpC+swoWi-(1w^XmP z+}`5j<`y@%-k}=imw61qsX409E-V(jiYtmJ$#UJOx|1I+tYrI}@AdduqOwx2z{bSv z@tICxba`;lSot7(^P`g6;OTpbXX)%rHjzsVN3ahIttwf>a176v>^h=M)!rTdH02Wx z{pV0PoIie~s9VZC--B1v!F ztQELh79<9t0ZZNJ<5lo`W44eidAjY?p-x%vz4pxfCEIh)wa39q3n&mp)06?$L(ZAu zgf%?jx+ZzFMJji*Z-XcGh3=vKUKICv&sow)_ip;RqwC67!Xr_#gPyt8_Hp;;P6ui- z_nsqM$k`R4uynAAe^~p~16AH19H>Sku$rvv0CMD z`WDUq1r9ieddq@$)ugMxyh{cqZ68n_t@ao!_Bm_ENmLP$1?HPMiM_u91=yrklDbBV z^z4%)i#Bgzz421nv8fUFtiu4DfoGd8t1y|1OR>L*e+qSfsshZyMggSgsgvHUJpYPmx+is-f zYzfJkf7+g%rYY+w40jnY7oqs49!D;Rtg;p#16-^--Crsh3`=3ReO5k$S!PX_bLxLg-5 zChwQBE(cG`zt{zIH?k4_GN8W4?GSf1BEn&(1wySJ{R`ECK`WQvUM36+_Wsw*# z*+UKALVLBs!gaIuF7x;@N|bO|GxV^>BfPViaz}bKcG8q~eRax@MQ%We`$lx#En*Cu zurJ3%UuYVZ%0Twbmc8;Hi?*+4wjtW9j)cB|v&&zvI9s{jO0(B24#mZxf;45KW&X1o z!3KI@SVDPNOxD+cd*5>WO>EaUMd*jEnY&PY3kCc8{BoewyQr39!eI;eDF{Pv_Q+Z1 zH9i;<>HEtnz|$hdb=Ly$Xnc7AJ>|Lmor>zoBreeOo^C~|6C@^u<40Y#@hPnn0hCVt zAS&}-E^WwFq{QdEv$enjVx-`HS~1FC$sLiiCf5nE6&3^xr)>ziy`aKdRwF+HvbxJb!_QvrRq3k#AQQD~qOhZPTuw!m{JCV^cV3v>YFyUz<>n}^hNjYK%*j5j+?3tKBVgauz zfSjtV|NH`a}VF0aeCfSG|duB^+LcKfV0%wa%IyXx!+hMs=V!%#!Hr%q!iidyY+0!CKV!b#lZ)AP%;E9+mUuA1E2X2#4Vz z>*tsI_p3$WAa-D|ZzT&=8m~y=-`|hwP{9uz?2LG3!AVh2H=Aya2Y?AInoA#zRQ{-5 z6S6Epst9v`fXClyswB(So~*mtN2TQKNhTb(1)l(HS+tdDGYOAd%3|mn-TlDJI{%|F ze!{<+Mwcjd&psFnwfV$2DLLQZkizl5sy2IHs$z^-EtUEI_2E9c9c^ug=w>g`9q2Xg zK=eEIITkE~qRaz-lz-YRLBsc+tkrb9Qwy>WxO|%&!zpO+G$iMp!xBU4s3~ig$MX3h z@_SrsMh~M)OqEHP5O!@ao*g30NxdS;euZdMbr{@2ES^91Vc=z@Hbs1tMQReex-dp^QiPP^d)EG~s79JU(> zG3MymO>B2ru@z{u{)7{Ryy9M)5tzTmXX4li0+$IQLeM%a?ok;MBk#P{&4&7hTc5eV z=5da6p76fvzjdxccmju|I3;FnN!*FS)Oalq;9xw;Q0b;{&zKn`kmbUzEw~4Nj$kT# zl1eEcKI&CCxcTktw5YNf0mrw%W!A@NYRE0{v$(K&Z10anmzyq*P!m(EqB0&WjRqN+ zK8}Z7p@5OzWmMRkD^-jrq3{ijXU;5DUZ`_CWO(&pAWpZqB_db%MCMr^iB#Ds5^6IWZ1 zx--#k_u2Q+p8wfbJ~ihA7kOL{_6R0S)6k^pkCTE_%PyF9B{wYPe*+Yonx0Z;*#bZ6 zo;Yhm1<|LOr_S-6T8}5Nc9()u)h|4c)WWIjSa%?t#RoSoKNh-WqhOa!*3XUy??Fj< zNrL`YSCu~&ok;yBh7>=e{LN7?i@%3l&9hok|9a1+N#`!O?pN*E4t9`>AkP=ru=&kc zM{#5o78=a~q}#(TX)cJOxM#FQhhkG-Z%HKOikOEyTF~+gMSO;$J*Z+?;Hqs@8Zz~@ zS7v4@oG!=*;Rkp%`T7`)LY(IdHc=9_Vwzi+BPg6=y$k8`=Nz~uDaIVs)JelwD@{2j z4hE%WuQ)cY;5}CnG5mU2%0@MMYF%0KU{2B6Uj zT!1=cafrkW%n?eI31!N>;R&4whI2Du}2d zRlCe|ExN5RhBpruojaD-t6ZM+V-f1aOtC)Zi}*k=F!=tjC-fLh=dkw` zeiq#}AgaYfD%7Wu)C=<#HK>fg4(H@Pg?Xy%?Sqls^pF6}g}Yh)&-xsTAdF^MG*2b# z>`EA~0^0;s?vX=xKW|zF$GXR{F>?A0RYqrAWB>e~;NzXWXw2bGcEQ zYL%QM^6M=W+h(0O#quMMWOF#UUb_#cEO3a-UYcz&cvVqD$W+haKH0tIUO=BC2LJr# zDsTH^v!(xaZb2x^6ZAe-Wc3X-{tjp93n?zik=cx(^1p3O$m}udIcihu32$uQ1Q*!Zp~!j7s-5Wr`!QA*ogq`BLml(K?9wC4-aYCO0u6&5(q{ti+=wjn4b_jleMA84|4r=6=K z;B)q|{peAe)PE}nTEGf&qSyVaxHuN-I2=`6lKCgmDYf&?>#z{}U1eS`M9Uc0 zp128|5abWO2q7lRMedk~*F7u~t%+elT1L9Lk@P(O=ZH7Nv@uavl|=v)mUz=UY9=Z$ znmzM`h<{RM`ah5okGt?=>^86?@*%*fhlKd+7(@%|dXkyZM5IQ}w!kNha?X@>p zC_*4Syq8ZxmHKm`P%UG6&&M}qEeCN;<;izM)WLnaf7hIN7lUx&&2qpo{KpOM{N)`3 zORYB?*cyCLpyuE1$N~lw;*bTd=Q3c_?lOmIvnmK$iiSQanIADG@83lXWvMV?Pud%w zdX;|kjE^&coizD6tK-v+i2q$i@;JWz?zu9f%u@DsM;lZ8T~y!glM_NyqyCgq>UAxU z`afnGqMKxwkLe`vnao=D_Dle9(e+RIoAbB5vH!)hw6F*_GfB#m7mi79O#4}l)g6dX z(RjMglQ}mEkyu%v_N%EO3bQHi?T23Vpc;4@uXz*Sc?tc#}*1UO(LCNuYUuT;g zK`p^+7q_ZRMSU(RgHFL>+3kxJE?;r?W#tzPHI16l%ZCeGw3UT!8eQKun2n`MCX$lae>JTn zXpO>T%v53VVO~_OgX0nSelYXlb^p%5EH_4DMU?Hmg}hDj6yujlpEYn3?Hp~*8wPZh z{v+qK{#1=Ua3Q?P)Wt8A5pYoxxY@eN;a~hNu=v$x)xgHYFd^_Q`mu8mvn_mO zPXyfqO8%nA)3Hj#!8w7cn^=z>v$FTGSOv-A&1Xp0zgz+Z2lTzqy_NSSFo4Obz<;QW z#5hc!tG1>oCgD7(CHDkhD}fw&`2TA6=!xXi{Vv@}(=fT$tox;O4AFa;hd=*bfnS`$ zCfEn>3#jSUfWGdNJ>ZJjZYoV8YRb4g3~X#4$hR6s_K8#O=B=A6urBL2EIqk)&`?o2 z$$n(|Vl20*D8Tcz#jo-$I;p-J$|G?)VXw@zXQ=I$@S>}_C%BjLhRCDl+?$h|b;rvG zAP4NIYd$0fhbX(UD0CA~`oUxO6)*k%pgdq1YjDiH9~ZW}qhX26aUJ<(@zik=i?O zT^rko!(M45-xQ=dzCqPc^;O2nr-q+L4^+cAsb+TYX005)v8|*oCHEh%B0%FMrb5LL z8<+z{#pSmT}=xm_R$-#I)%{ft=WGM-8EQOTiHD6mF5q>o!gRZ;q& z+B1Q4foINz$0o>5>iyHvV^|!aYegW@k2dgVPB`b!`jNvc^Xhw{b=EZeQnOdH z4#-jL_``^_2qm6i>Unh;+!zHa4JxQ`;5nvk61)nDLS+LRjkJ4Ljq-@s&i31j<7SWj zeCx-e--J&izLkch6wf!6tZvp035cl1aOgqFAq->({%@zZCC!H}Q;^Licrg51L0)LU zPAJ1zL(wp{S@|e$WWUCW#DK>pCN`r)H~uuX^VMuToo{-zUq6ptw4**b@sTOx!ubQOnszQR@dWP)tmV?gj=pP zF^REIZR(^Dv{rW(a7|F`s1mKnf;kwij14gyYK<B^oKbeyAXnVwuMTp&IhuLOS zof(NL3DOig^+Hp$M>gJeX{;;uc=n_#Y%4qD0$dz5 zj4r00JE-pS@L}_ZsowjsP{!XJirD}8%YE>=*xCRZ%4}Z+eqLx`FG%;^e{4Il9Qcw7 zL905`5q4WXeyQ0k`>Xf+_H|vEQB}q9b(>xc@h@1o^yABLlkYQ8sh_L`8OlzDQeXe< z5km8uX(OB+hVex`yZ6MdL`x8r{=yV$Wq9v8sMwLuodPh0!U`c+3u2~f{Img0Q$s|@ z1sk=RdGtkw&gl5JwrE=R*VmyHwTl&21jFd{1aECoF{I`t+sDUgP-f+ zPQtuB*yxr%+p*VcMkm}J_TN_BZR}gx@wNoEr22%==FyYz2w;>FO=y!JExLBi`YbchH6FWBZnW$&d1exbkNCKcP(RM$+7ai;ZQU%?Dp>{6~=6 zrvHL^-X~`=e=IUSSWa2$yyT@&5PH=q!=fWs@Y+@|vzC;8t0FvS7C#N4-OzVIvQbQ9 zcFSMzS}2qOwi+F{P0!?rSuzdn+2ZL{aghkrm`43|2XyLr;bVK!&*dcW83YKxCS~sT zBFpfyI@`E59=ZhqA6GHqngVK1l6Pj=7nZ$a`gC;kIxwvej^iu4B&vx`olz9rp$T?l zm>m-M(7M7Xh4=VxC(8-!;FtriSWg%U=T(xvsNg!rnTpE6!<&&U?MJT97Dew{uKhgH?~tXxuLYDZ<(;YCM!_G(>9^co+Y0ZT9ov+&D@E%fOb6V5&)Z?l zELdl*EQLFiN;>nU_bKqg)ecsr;!KfbQswX|IcAF&LPNw#K}CpWGJ{lPR}ko~ljUW) zq571RS}&5#(qsWM8k9xf!1BYWZc(fwB17U5Ht>NwD_nO%0x!*}59{dj@VXRIU zBJ~;<5ggFS(rC-TvPzABa1l7#WbHK^HM(@5IcoS(ZRol}@AVV4;OM5+$ma3RDKm$GcB%N20t$A1AcWQu-Z$qTwm^N&T`{-HMqne%=&iyjrL z8giYJ;wfi`HopWSi6a-%s$kIz{{9cNGQG$l#p=YJ%q3Tmq=o5iR3tnX|+4noxanicP&qGv1~UC(3YRF&K6 z3xebW&$C*IiOk8)$|`6&yhjrh&Cl&V_RU>z{B{4OKt&pUQaS5^zvwdL+XU;GN7v6( zpsrur{T7@8Mj7vCu0J_hrkk=$vU7e@x{}YAl{(>6H~6+Y48}FjVlnpYLIA10D z6L&DN+jdLJ10Z`wL!e%PWh?KG1Ks>fu=Q5{ZR*Pz2L*0+p!L#op9r1Gq-U5eqD#|Q ziJjc`w9aVsSa=ef1O-T zWZgZ&=#)m6+zx%c{E^lH#AfYMe-SHejY0?XT+DGPiZWFrcX?7F8`+9P7PV;HVr{w}pet<331Y%j6XZ9l4R$6pFxY>z?w<__Z!G1e*6C7osc^3OZuDx_|FD32J^-A^a8N+EIZEJX%Y z2@8c^D9>23&wHadGbtSZc5;L3an?HXKCQ2HeN23Il)epgtO9?f85>6jg?bG-WLQx$ zS{>gY{Nhe4AxG?wrrWQ*jqg?$fAHKk>s~XOgNLns@Tn8K=qVT0xwO%WysUJCE-{(;C3}B}@XS=2M(eUEUu?uT_Rn3dvQnz|K z!9PPGgkglH-+wkq#UY2?-&?Tfe5EsorN*z0OQUpZo59Y1asYuNkLP zR=4b{+rIQYCwwIQ(bw*4JvKPlzQS|HG=1^jB*lkP^`~$5rr9-6C@9ax7HIiC*CoC) zU~RGuFIAV$gzp=%XS}f8iyN(@5hE)F?^Az1dn6)f*oj#)UbV`|uQw)|Mo+GtHgUej zCt)#IkD>k#{^LfCL-dbD*}Ad_%;+aO;9%w$4^)_XSA1aDvgX`vrrChc4?bAtGWr2; zid~j50+?Hf;b`W5)`vhJW7bzJ2oN?Zz!I<iCvG`rZXM#g zDZ%-8ZCgP1YTTn6qbcNTh8NTkE=u-BxVBHWR4fPHX7b_trl7ubIM-o`<3mP-^6qm# zOYH9>>e+??&#p6IqaDaNIY!mm>pa0^7IHauOoI^ry<~@%Hk)U z>VI=F{TAJknVc$642zonQCF^?)Z$;KLw1^D&Zm-?E>$%hiu{6vI-2dCuN$?lpdA#f z4c8RE&1Q+N$l-P12y<&k?-Jh;b8Yd`l=TkGw11I|<`LDrm7ii{+I(myDr&NjXho9_ zR@pG1pXG?e`ag>e5f9MMJ30$#p9{Tp&xETDtO{_iNo4lW&DBsTCx8HixEW*CuKoqs zidn>OCVghF$zLAs=xNIBlaDL~){&9t7&2DRzm%-pleW<1-v8WlVqpOEdl|aN#XOX7 zMv__pY%aRQ=UDLtGsLVc01?#*j`Hx-f(wFX19J$Wp3 zUl_fOmX*bkJ!Q!D)BNu_3p1qc3v*7F`T?=+&sRqlmR^%vnASSnbMU)W1o7#`k>2Q*IS%L(j_G=A*Gb3Q+NTmt(s7L14xne{{}27|sMol_cM5 z4#Wo;0oy5rlmsdGK?X zfRbfQ78H_1%0t!yH?a%7zQGn;-mkTsq16_I;uTkt#mQYZ8#a9g zRLWDezrc;ZoZ3VNYL2+JVChC9f42J)N~n9-QUTNG%Gb}>%oLap^4rYr2K|fT6tzHq zELwfcj*T_|!d+^kv-8l*%Fm$>5Hdl+a@6?vh+~vX-$1+D#=as*&~Pq(8q?CxK|2IY z)sS-1?a(`pgwRRY%2T15)x-Q&@flSAC6NTegHu*%KBU}7Bh$t7=TK>5T5i>-3~B#0LjkVe0w7KMxi-c5YEK=q2am zg>y^NNzJA^kfU1iS8y!uXQ^;YF+(r^4}C>K&57HrD5{%HI;tGV=DyskUh|jr1}H6< zz5KSV$(ux2wP&Fz*BGr0G8noJ6gmQKzqS(CugJba{>xRd@|lc#O=Iyj|YbHYr%FgSUXO;<2p8^4#p9OEwApT7~X(1p;9oO`| zwsy5EI0ba_M^(D(nfZ~bYpwm=na%&xs3U0oW8^8AW3cqoDfgDp)pHbAR$@~`e{-2& z#dsqULzYz^hh#PjNZ`rumpC-I6m?^xG+v$*EwVE+DwbWxFL~wZ^}E;Fa15MYrv7hD zRHnyqn^W*m79wKuaP{3sV^r?)d5^OL50^)dMESLC9*Q}8Q{Qslq|=nmK}!yr-FKt3?iA(GR7yrSSkw0$@(mlMrV>AO8# z2ikQ(=$QTSCSMqgJuE)D**7>SnT=AgOrNt2EZCYcx#R&RgorGWVvqiSVDl;yeUp6fZRxGT0h@Zj!f53eq@*2o85X4e zT>X0p&{sypeTQ>bv?;@qmwnN!((h7TcnuttmI3T9qAk`L&GY@R5av61nsuxb8WIYF zxZ`Fg$3&ya&CB%fINeUU;o#i9u&Lrloqd=ei_)zis#W z%6_i_aT@%K6ih}$#+MW(#in~{x)!LbCDjfV9}=c9@bRZpFyrPiP~ZltvJ1>;r_}@IqvRsAwwI%3JB#H$VB1kvF?` zd8h2NUwj2apUHPLL~$LXJW^CxAwbIyg|gnup5>MA3g{s!j%^@Vi#~11N}QR-9Tr~$ zODuUU-qGdwTkIM9lu)|aZ&G6Iy}Q3ve+!FwObB@WbfQU;Z(@I!++;)2`7~czhzi4{w2hhdNK)bbi#TbtT&LqJJGi+SD#4UsyN; z!~hm{KK{u|8<1W zY%Jh(sjHSs4O6>luE4-FK>(`{9tE_HTIAyw)G3plE%)K+r{WKs z*nZZNn!9=8IkVr2(+#^LK<(nwcRAR6JHd#_DTlf$v96OZXPlzoITxHe73TuSPxCWk zGRvE0KufJ+vZE-6KpaSZ1?=#}qo6>7X0^8R{LdF0&|p*FBt-SZ&7gI~tT!mQ z;g9tP*QJi`C;|oa!|OJ}@LF~GWTQiL$>uq&R_93;E2Rj8W`!Y$nU{@^xKGiP zb^KTa2F=~+^r<&7uMqK>!;*=%Ucg`p3r9C>ye=;o?<^mo1HS+f!WvGT$6E^ju#>aR zo)SF)W*Jy1uig#qWsbF?Jq8Rc%Bao^inuggA1Mxz+ayv zRe^n~itEFH@^#7Y&7bGjy^jsL7@ii=$7Bv21co8vRdXIY zb#ZoOSK0tOnA<_Kdd(EXyX58XO2fx*INRRYZOj65frfP4TIAEYjH;AQZb&GbiH`NZ z>C&hIF`;CWuT=?piyOt8JmfgFT~f~7<|cu?3TBOVG#t@Q^v7p(a?NC&3Twp`xVbLL z%OgoG_55p}(ET;^Qmjv&Pa}LIheH7rK3tzLH4-zo!Og{#l}YUfFLQml(Q1qZ%KwaO zap{+CkD5(LqJSw*Avp^`k1(7g!7CHtw=j~ zu(3h^;k%_tb^V}s@1?RGz|VVkAvQ&K(%VlV`n8ut@mh_8$dZe7G)k}T$-X#qAR}c# z%EM@B{Tgq#;C0?gP7k3_K>Wb{sJExl? zBLTdtqmiT@gxo^*Du9&@cjcTXGbgLN(AyAz$e0YgV|M@=w!FO?37^%?`jCz6R&5xO zUw=Kb)$cIan3exsSkpbqi8LI+E|2y?@u-LwZ91)ZS%%k`d7WXaxrl;5w@uLJ9*;Aq8eBReeb&nb=F6%qFB)~ zg{nL(Jx*v5{4!&VjF2{>qI%81ROCB4^H&M$O>_Li*k@y?Opg#N5NqfVs7pXE#BtWV z4d3v>s~g8WG*jm!^^rjvs1b_5FhCz!KIh$M5iJw=TF#Wsq{o-Ch|U}E>qWbVh{l-p zWd!E3yxxi8uB#jtTD^!~C;u~5cd&aXoO$Khp~h=Wtibo4{3=cascoug%E*RFJ5 z3XJDf`AxtY{^P)P3ez`MwQPT1?3tj_G<>7KDy;E zza7D8#x2|@hl5rhT_Y=&JIvx6Kh8$@RDV-`cnrLsqbE<={hfq4`VFWA_F4+4U0dtm z9Ew~P-;;}{U%$Gf$V;tui*#xehga_SWDKgCPrr=X0EO#hvxJy*9;%!B=2K*1ImCku zTiRr>Ja_&ct<#jL5xKeWT2Pv;j5w;dR}C7C>ax+C&bRlttXLhWaz4cITo+NcXAf4VSCJgMw79e>+49$eR8(vWtaW~M|< z6YZEzQbDRb6)%VHb7@5^EH1$Q`shB@OV=@vM$VDT7oWfR zckXK6B$EP&ZIN(F9RkOR;Ud9}`xMu!cZEiSBch8Um!1BxXuQ^og1uYedM0f0Gv~X1 z)#pfMQ7%xcB@xVnA2}r&Y$?=by2v)R7Bu>Jc=d_O%;PmNY?6qR;4d81XT48a=aeCY zw_;Rdp+Lk5RM$@kjwjy~XSJYWVj{OkqS}^h#PoaMB{jOiKvyh?B%zLKctY_0Et#3w zH(@IRz<`t#*IctI+7x;(0$8;jifI^{6*DzB$~b7 zK%e+7T>;5!pB_7IFZq_2t?vU*<>xUvZw3BUb6^28=!@?O^kvD;-m9b>N9p&0=y(fX zf-W(TUi3oH$sG)84DF5bB2rkg56 zUtdk~@SbuyGno=S66L+qZa$fZzZ`a?+A?9#=lD8F-6|7BUZvxdg0SkF8w1*vVN_#i-}1a z!e0#S*K9p!i106^_P+@XJR%^M9mT+B1RF?9^mZCMa8q|o_UGXDn)9Q;o#Xl>Pa*s4 z9HaDI(~k_XmII50YIXYz@cTEhSa0j@I&fDC7a6wE!hn=6#Ekq4OFClk_0-Nm4*X676GI<6y z{&0Q7Prm7I0$Wuucdj{NeTYVSB&GZ;vK z&7>YYWSn7o#87T|UJ!GrF7-2}%dsGFBmDkk2Z`E9H^ahZ& zMo~hne{nd*H zSbD%*I)9dGItfi1@;fvJZ+oC%ZrP7kQ%eYz@tGRq?0{T(JhYqyGEuTN0T1P4H++t1 zBjulq8OZK_lT;f)X`YSe{bpF0@@z@Jfvx(x@BZ4k2=!?|NjVljE_fN`D>#VHm2PEl zhnmDP{loY%8$!pk%u-G}qdm}5igvUNXp*Gr$^#GB1lZKNp7ISc?~OL^otoNG8FTo= zrkHNy4RB3XOmeEs*n)Z|1d*Vf0hP_1ere&H8wEHdCJ%z4`}LVDjazc%oV^=TBfKDT z3I!%wb$9}t|421P?yOAYhUQ&oQX@mbH402A6D**xu*8er%46mn0Abf^=M2VQ(euAo zqwc6?Zv&jLS@({XRgEe7vbB`sJU{q|?o9~nkTSNT?1p7Xc{svWwEn*LPbZhK*cl3Y zB2+xG!f2xArJf&Gh&v{4{&L4beA? z>;=qNYA?T-un!{G7nEV$lr-E_Ia!kA3uV+a0w_fbxY|)MWP*tk=JD+P|6hmx zT*B0w(hQqaQ2hDx%rr1~!6#rr;I{c(cCtMn#aU3zbLZ`kpP5HIIl|JbWa+l!C8?gz zV6(W%KsrJ8Xz))Bk);WAS9W%NMLo$m%GKYiYXwLJaZ9eQDFO9vyyC&Q=)lESW4s!2 zYnhjPd>s!PIz{$cAnyUTY%%e%O(EU0D}%nuQ76r*??=CxUrfV&?6DFoBo^Wk zo^SRDkw&9ZZ(b=AA=6Bzj_dhH&M;wKpJ1mn>eC`d)VcENaJh)x0%A zikDrQr8nMicIIErSb|<*w1yai3BL!j^LBmL4=ZslNXYh z`TCv^>p!DDiK!$Qd>0aLBenFosNs3*TD>}2sEPa1kr>>KyX~gEkpFRtOYNJu8uz6Y z*2*p|w1&|dp4u47xcgUHa8CN#9zY1`Re!IYI#4|WZXX&w?bQ>*M6M~xiAlXS29Nn_ z95+@4CYE9GFs*e<-6XsedLS=#&-l1$^h@*C2t9v-u`dtnlMRbhPyyMJ>aHp&A=NeA zJ6fwy2YXhgS{Q_AA6)Wy$V7md7^YGD^JZ~0rP2e z&_vcPCjzk}at{x4k57+5@HlxKhP~5H2hsd&IwICvz`mkI^XVDJbH$VYZP)MZjZch5JgvoleCH)Ysp9u^Q8GIZ01IXVVGW2(XtU)2t+0Aw*j}(FvY;8oBV&?!xsx8Q;MBr-K zZm0mwz~oEUb-T>$W5KzB;rqL}VcgX&nvp1R{gcx-!9nZF3xYZ_laK@V^R3!gK1wK) zEO@I;>;u=NA&Bq;`?gHmuk&h%Qmc&}^UrwmsTTh8NN>|?kWaQtWB(X0yau&R*5fkZ z3i(o|rW!Ld^_4NLg9ALQueIgSW{$R&Pq-vBQ{b6gXJ95_%<=FApsP25|I3Vtxe-l` z&yqhA8gtU;k{AHnl*&wRyT1>w+t%LpNDmC*+Bxv(Dnm6I#l`FDXDP^pPXJ5t@% z%tLrlReD3>wc)btz`+mRk z-(d|$OTtrvRUS?7-pt{8yzbw>pMBE3^z2&IM6-mYI3p*EdpRl*+Eq#2qz13)xmZH5 z6hAsw@Cj?z?@DpVaA|#*cF29}yIv!DqP3%XlCSs+CS(-Zhf66x@$huHj{1`~k2bm6 zm4ElLcQ$zAq?|n5Ls4w{pqj2`9BJ^KXbL*cUUBV6(DAgtG9B?-mCZ^!%(ShKe><5} zK77cy^<;?ard9tVdfAz_DGr+NPkNr;3}$U?+H=Cgxh*#sc@nx($H#O}?@9}se|^gJ zpM>eIu^nj3)6^j2tsp%45x#HQ87Q7r9q!4qZDm?20+6Xls3gZYWUw&FvW%E}`ENRE z)T1nyHk~CI9NG5mX$PLg zaKc{q-YF|M?GU6!aR4HdZs%gf)$q>PJ{oyJypQbR@Yx7|$0s#$RBo7m`u?L5j(%>q zi)vPteyQh~F#SQ3{biUspSy4y{TkONm9-}kBzG7ZRZWw?rHZu9hUa7zqEWv zv1%*)G3X`lJe9JGr={?aM@@iAsb%ii>(#>M!nMy&%cUY#O2QL{U2Z!xFyldw7( zrmd|z0^6c}(aE)ArdlS3r+M>(h4BP9Z8yhsAq)z>t?P9*?!#*$DFe4I#T|x$4Ig!*rhCcOu zRa}8dUPxI1j2-AJiMQ z1vdz@G^+Ib_mt^i&f-a@m4iWdVHeB~^o@1FL0j+k-`CXCLUXakdP|*rj{f~-@8Z;p znHddo>=OrYN1S*FR=O-nri2uq|);25xXWx`S-J`d#Q~yIo1z zynlGi596@ITXyjJ9aPqakvp<%RGBV)16F!fD^>d}QguMN#pnG*D*oKrfQ&r1O3|XN#Bh= z;^z0AyJ}KOa5cFTb#5alTcswnsUNt<>O6?`N#|xw_nzMAtlnDYq_G!m z(0%bPwN{tl*s7Xpnmd>D2JhOwzgW9C60hZ&JrLvJru+2H^y0-Uu^vr&AF-Qa65A(q z$ML5QOr?}(DVO7>ok~ND%2LD2&U=B;2tn;%KRr%5wF93I z2dpjEz>W^nDqil5nJf<)G*J1??5*LFR=-NfUXJ>$Z=}!Vql@b{*x8*(cwQJckU5lW zP~K)>r~fwCY|g70_pUbqn-IOltoYzt5FD)kh&3zd*x~H03Fd}#41*2CUl^^jdZS8j zh1G%V1Ezc5CYW6@D%Kis=`Yi)BMzTlq=(|?=3|FSNOy$X33UyY`Qzr_)RG$A?e>wB zZ^d-{Gxi)4@yPh2^IyL64W~RZN>8pAJEY-v<#?}mcgj*bJAPnzZ);L<){lLpM_v&d z){yRhCJ{x(&l6K-1CoXTxKKjLMaG%5dJ*u}HNE#8b9ZsYj7pwi9?kq;*ucGl< z4qE!T9ckG`(_nBL=;!J-cho57hg(8@Cg{}A*Eb(1I??*U-kR)&ZMVw}23ITe{=-~A zr@Gql_4A883QYO!K2Fiw6rQ*@uk|mlzB{m5zalk2U488tpXdNkrtO5D-@c$}_H6(4 z&7#uB_dDjCxY-r@5oTcE-y*Kj`b;WFhOgh&sxaQ5{PRP`L2dI`(jvjBG((#1sYWCf z>m*$MsH$`20UNrstlP|n&)saAujoj0O3SP0_RUeZ*r{{rGt|&GXs;a{%}!jjsxFc+%Qm>K133l! z3U%jC$%g{q{sz|izHcuoDlry2F>@|P6x+RR$+xjsBjF3{FQuRL40>1JZ39P{ zsS!-JM%>!7p#4=vd7J9&0a-?V_FL?FfO2Wx!At(-!Grz}#UC!_t5k09clgNp4f8tM zGr<_w-at}Ccjj_9uamKQu0*fs2yDj(HGj@%(csMjjWbqy*0jTOI}B5tJ%Tp;hPNuq zJx=MigBD|P^Y@cP?UXm14J?C%U`>@6TLY$RBhJI40&Cc@^|}GZYscokeB{i8!BDDY zZcJ>y>pYostR|Ty7kCMZOFxE$3}|8#zgvWrT=6g1V@ppLK6lHQb9S+mHZS8I9q0wc1ls zE1qEW-$>0xFIlgClun;&pO5Wk>5YbTZx?JrmyKSD>u6dGcMdk1Si;1u|LCA7P7SpK z9i*P!>_|(yf2#b*4}59pCgp#3CU)kSkCSML9RUwjoUEVYlD$Zp*X?pD+O0ybtZMss zQQ2D!WQ&*9&Q7PHf^d__zY;?Nl;h*MbBApI`&?J=|HO;r3g14*PDNZq~RX6*Wj6x+TIJNuPPig zHDXM$5m@Ulyr4l`C&)&9OD2&{4rRD>6a7O6(mr+OmVw`dyv8P+clb21e!Af>%Y0l} zcq(x;rD4#tzDmhPS4Eb%%7ul+V%NL=??q+e-A1x~ZlYaBwp+K?&UGbpQ~mjFyYL`c zv6k6;JzQJN+peGKdv11uBA|xg2-la&L-LKJe=EB5<@VZ}_u0 zCi5Ksp33A($0u_SY3XLk$#GrJ8#{VAA-+=mxq}0(L7scAm}W(JeddqhvdV_%8-A#l zyW*9vuDN%1O;w}6esR@;U~O(tDtRa731{u9q}DZ{YnFSI>I6;I-RGQF`m(G4bhCB2 zF4nRGsMude%AQv2)YD$A;jc&9n`NGt+4e>MhjeB;CJA`P$p)sbiQcLW1^b*bY!6&+ zKln5=^OH}(vG-)l3$|ID?|3y#nNfLLDjy%TH~o6N@3yvFP;&E|cP1u3D!y;f!UR3g zmZdGX!CY`9VT~-~^drmH&aVBP^CWHP)ANI7_e0*csh4Xxs4aCk=NVRAb$fg-=(iYK zw-l%HXW4zoXT9NmTDjTp#oMn7wS4!1RE36bYs5~Iy$L?^j_lvIpPn_?_SUiM+x%9J ze*TZXPima}JZy~NM)mw@=ZPiTjH*_fjJktIi#n%2`>e7f*E{z13!F^oBu# zPUCiazi+qKwtugG^0q|uIHinngLEn;!37L(evNDIylrRLP73Cw>y&q9|IAn@GqQ;3 z*D5&ba(UM;ROWna`_ptSwn~M5!kAgFqo!)x)x@W%d-I>B#`qVgW{2-1kVz*Gl@#3L zbW^O`8-9QhHv2TaH|5IT?0nLh6I7IzmRh!CTX#4a(^t5Jt{m8)V(MAZrlzKr3nsI@ z+7Q3$>d6eR*+aRYM&{i)r+*SJm`72(YR63aZB{FrZtX~}IaP9bw7@mmAT%aD@!Rm8 zucPJ@Yd=})m1A5)i3Z)?5h5(6L2CU$kls3%!U>LjQ_IPioA&ULcipkl?EfeyksjC^ zRB?zD>s5Cu>`w-Fru_%nW`5B-(|%-ITY42I{RKCj!?hx=4k zwmD_tKkTt`FiK0hT~*+gJNR1ZnA57GTGxM%zpj0PBPPzI_3M>g%}rRVTdZzwzO5A# zGXq&^m1^crlduUfPU@}ktM7!D>FJHes}}d}op;umcYKz9gh)#DQXWb;Z%(UB>;TL1 zRy`FPT4q)9u{aHMA3bzZ#WWp1wq1?lVW8XFIS|tEG|6gudxpQkIduo-Nj^0AK?d^~(R)ROXsW% zZ1|ouKJK-_(^Q8vXU)*TZQt4hlam`QLVVhjuUJ3FPkXR%JPqTtiS;Uu{rkK>f~k`U za~=)F{Ftq;I&L4gTgcS>+)nWdGEuhCn+d+awn`ZuP02#qi2Gufyg#PmJ@>f$QL%&t zE%qNbwlW){$}7ym_lG7dl_u74cN|P~)(z`w)o>ZJbP3zI)6|_#$~dYSy`Q0+yj?G0 zL#Po2uSVQ)^b@FyJ-zLf?R@%qRgZ>ej{5>1|A?^*Eg!A(+Ow_9IX65(ThptjZIq?IG2BSzP>RyPt#k)c{&_) zD^6?!4F&f(eAF;eJ@?vRbh_hqo11=)em{Ejot+iYAv>u2#X<6WvTo+y+io1yr=n!5 zY<7Yx?z%y-hEKQ~9=$7T)~At#DcDE4N~ue5Gj}(2jU_w9gH-Z=W^Y}VS_R4Q7JFi> z9w$27r(9P*zY(Mavdew7R`EOC`fu5=KY%%t7v>Y&8-`EYq=vd?1?Yt8f*iN#I#0c_ z{OraZxVF<@JRg2KtkZOQ+n7n`n>kxvsy}J8qAkpc={8jTsI?1t6X)}+lR_t#b7e3-mzy+b56Q?J2lk} zzmJf;i;E);ghbE#b58Bg6+X;LdioHrtS`ImHCphUvdtm9jS8?ARw4&@yY6-q!JJb>16wRZ|OAEyUR67u4Tj zxoHyu69PdJxxZ%41JwAfJ_1rwVOU&t|M=>w>KuEG2=geSQ`StGw&`l|$BgS{DOE`W zX;}l9gadQ?Gane*FKHwibf)DV)iOx1UNFqN-TUL0;J6;Pp4ss1 zv_-|!w*IuttcS`qX_I!F&Q{yzva?oaW*s--1%>|vLNb&epKga8Q@@so-NC+8&~OFR zBN0vKD-0XV*Q5-jWq$SE?6bJTt$dUdW^ZRdXzGef$#71XI~wA0Cp>>{x@>fKc58Tk z%J{a{1H~_fsx_Trhc1me=!%aWkycGiBGsy-=At6{Ne1XEW=*1Usidr{-e(4 zbKy;Ub2-t|aevLM0Y-wyT^b5tAaP2J%dp)2L+>h_5v({?J z9`q{f@Sthy_=AANwL5koGeOnWY@JH*zy=IRczAs+3)m5I%E{rA*&@N9{NO&)@q}QV zs_j0-HK8u;jXMp15g;xk-}`~N04BK5jI`E}9P;$D+&VKgTmw$5jOi&zwFvq)2H`?kC3fY=LA3H$F2c`K?BC+*fFgGFo$|^7!{gug6?#EL{SZX&MG(%qf zICY4mFjcV~P)Q_!ik39by_woN9&_Q&q9tN12~BqiF)CKg@XE|=81W+AOZN{Lo%Xdm z;F%EJcv06VE8#!gIgfJOHPPd43hw?awlh<6>WRs+uCCWiF*Hp5e$_D>ra=@w;?*f}2@JRRS9>qq+DObey~>5fPF5_e+G0|Y1C7ZbBq z_m`F$sb?B#nPuPDf=TLqK3e#+I877#V^;r}e}&;V8f#VuI#i*-sY#>?m4I|Cg}6i_l8dm_?@kp8&r;1#60Tu4-aVr)9H3) z^$!}fzcMQcPaGYV`bvLH$3EJmp7le;%g%Rf;OmRgaRC4Kx4rXl2A+NJx6TB;{72@e zzhyto!k^Jp1vk{avqM}k*R?qZu4DN}I`BN*kJB;liMZ}FZ6RxXohTNO2H6SfdLPo- zczI?CWvfZKi*|+vMyLOtk39u)4EB+8aoF;2Pn^{#cv@nXjYjJZ%Kd$I_ZCXd6sOvN z{JmwAo*^IiAcJVZoNh??Ht)bw@!IL7p5-=XTdj#X!3pWglp5%IXQyz!JBM^}vocCa zr05fFY>Ncn$5G#Yga`ip;oE)O{l1^){!7ck69wKU*Z4b|j^29uJUFaZxf}m^FnOOv ze7c^R?S9v!=LAwH(IU*MxjfAL^r$iZcCmW7%UpPjTW8j^$3tbO(*F@IT=|x>5gTVA zMQ;Kn9CPy&uNv%+51>4)|5LkNKP|V+!qDtnYJpmoJHa-~laDPMZ9#8)a(R!hvVEK( zj$`GY?`l9aRWs2&IG}l6Q#0gHjPr@-Wzki9dzJm!&SRG0vDZ{g(V$tlcZuVwZ$(Cd zo#mqm<7a@w5gx30pqMmk09sB(e8Me`I#AGv$^CC%3HMSQ#HZ zzr8>HW`a6qj%8*1Jb-8v_ll%99nT222`SZZFG<;ySB5#NUY6lLk6)zcUVrI49f2Ri zEmYomWr6(wnqhe3I;{7$?#d1?%umm4oJp9Z%7R05ok}%ZLE&|D-jiIL5P*ptDf2h% zhwG}!+pRo25??0$elaai?`$6CN4mYnoO`|;t7Go^O$2~4%-;N5m@tiIWKEKuY4hoS z{8BA8xe>1s_{7D|TD?DhQ`xjf#ag$|iTJfA*1C2~e>&%ko?8!e+_8HuPTnjH1<<45g0#} zeNOo%Nu0T$owlp{RY-FYM)B*Zdq7j>{$?O^VAQ&Z zcfAP0t0VV?ZP=f4E~D*OPKatMIqvyr|CssdZ5;!j^qpVX_Rk)ep5y#AqrNvg5wE2_ zpTCf!(-88uT*K3+e{^yC*;vBOo}}CP*Qj+#`cXznD@t?pe|%ZWI8p86k-yZ@-c9t* zEe|CcYpVXW9(}WK(4=H_iE3v5)oW`wCo>Ly8w8gl>Voy3zQt#Oo9TF0vguV#eCell zt4wuKTjs}JPK?U?-eQ=q>4Z7{1% zr=suarqg{-HZ(lLbvWGu^ITmHT*m~brF{&%LMF4!n)39Lto+uxetYkonKsQ%cJ$P> z+i&-q*CV643%qO(r=2#K;QvC2Z{1@$&f{L94IM@AlE%SUD~p5cmJXJZtTZyF{p_DP zN9g`rtnO#uo*3(7>V#`eX;DrtJzhGuUsYkKRgsuq_aLX>12~8(K#!U4c@kolpATx) ze_V0MB#rGaUX>aj(iZxmbsC%~wzhp8P-)=k#JaTacq7ZmQk^j9OpWbN&)8`cWWml# z*i==;8Ascd%!At*Lz&sZ9ZvXkw7lHK07p4g-cEEoaQjdLej zM0grt8{&Ase0?{xi`xp=+lU`jYfj#DMuRXLp&9#$H9bIe;R0wjw9krH@^sb z{oynk3+H<3;`-`1n6uaQ|Fr`Xz{Y{s;FDIJ^P82*0pKPb@;6L2`YJ<1>S42M39uq1TY-M-bCPMV@l~j0| z`y@K6Cd#$7rUy3VZ+FYwnv%-gRFTvmmj^x{%Cf*VOb?se#N%~b?euR1`}FU?lbHGW z(=%Vob%l?w{Te}OtW-j+K&?cfP#AW-m|gh`W#0nF7x%nTrDm%;@u^#Weyrbg_ItX} ztZgI}<5sHfy2i5oYV{*#a*k_K_it}jw5Pe>%Gtlx5$YBFwq?P*Vfv|C z7tXyN%t1%p06hp8iW}CC5N68=)qR1;^<=fY_qC{kUa7bxBt1-^Yv%k{_8?AXKD+b zF5bF#Rqvme$Qu?C?<1U_r(7g1O&O15` zy|$iwAQ+)RQrJ-_3(aAe2qXh4xHN(Q#+y)z=w!w61{P&3A#5q4J35Geq3V&@AK;bp zsJn$|k0v^}r!g)Kil#iYTUqY%oG^SG7d>5Hm-oW<-#|9~TlV?a5|5TG)#3j{57C(Q zQ*6mZWf9%BRdT?cTqNdtuT~-#T_A%S0#maxX1zF`%Wyp33kipX;KI(7ME2zus?1t} zL@D4qHU6em$@UGC_lF$Izf1ev`Y?U1s2dM2U%2V9t}lq@D0nB9$OT;JUP|HG-8 zOza)SkU-$yGCZfEqHV6$E5-Q{;m{&acC8GOqm&@tZWP0@ew+v^5ej9H6u^-q0z{2I zrGP;P%u5(5j~a+vjF-`un#5-Z)h+8*C{c9_{azN(d!M-Ba#ylvNcmS&Om=CgC!~-A%n96!v%)m{;b*Y@y5%^bTazuviKNs=k!1#HGq$ zKZT58!lRw%8irN$n0Rr>AH zDnGfTH^wsek`ginh;^=;`T(GWxJ3a7fN@_zn}J#NNCd>ATJTgYYmcE&MHaYhDsDyS zdpN9?K`8GcB(S7mCUIbGpLu@qG64^OoDe=YKm{Om*AmAQ9ic)%Mwkm>H?zSFL%?XL z`4=h*?2Ld7rcncIylKoDcuE4tR`B328Pw36U=(hP8JeSn;@o|_b$EkhF;R9%c5o{WksvUf7Uiy9ztJ$@=wv0!#eTGIs~a_|u! zrc!cfQ<5>3#XVjjwH~PZ*a&r3Bp-tU_#OdTV*$NbgzrYCGb?KYMYOoTVHS9mD&@tb zDpoA*-Hh6>vAUN18C)mf1pMFzJj`P?_rfb7Pr(T5XR)uTR9xFdD56S4o=jmUGqR2+ zg7RRbs*qY_!r84t-@bT}IWL=P0%E9ur@~4m!TTdyYJ3SbRLaC7z%EECzZvTG@ft$_TmiT%Q{OuJNebM8gJ}2xtC-1{>3lU znF*`c&!6Js0o68J5YR2^Ada+Nx7XC+rpY)}F20t?c&?oninzD3q~l z;UWTeJ%lTOIDrrI;&P}p7X0L4G#4tPNtQK&r^*Im1B6T5GGX5o$?vOY4mha-@L9A( zQw`~a!U(Yd(4XfMDuCGwz(t_&xWiI8A4T*%L$5qYr2z8-h-64;Op8LLL&?mguiq;g zBZ+IsLo^%5oXF*|AoQ${Z&yd`1Uq1BB{|gUeUM8_gcMp zf&G3sG=V+I^9?P%Ga_aQW`_TgG7I+?KsD}`e~U$QvIvp4$owGQh-FPy6N6tY6ITeP zgb?wXG4&!nw*_*nLD&MBxoMuY0+nu321AtLUHaOum2_Ob77LR$k2O&QyQbKPyu$I$ ztcWS~9yxqMo*n#qq`>`Hxfo_t7IxJYdeor*-e!U04=)2^PawDoD{q1be=G0)6Y6MW zJSs*YKyGt_tXhIfw=AO)DtqFYac^oO951u`to;Zwt42BjhU%!5!zMXXQrY(wDQkwO zDMg}M{J<;f2E^j}LHJlTR|CkJ3=+J<(Wt;`^RornM;IFc{h}oBG7=kxBEtJSMu@qX zU8{&iw|;lItl7s_y}w#*&xxf$=^96|WLvB=HZQsv`7DV+6(_#?h3c(rg4qb2FnAF- z#IyD?@rzj=%~B>8Or3FI08jJ$wOo+=+|&X;06TybGT`;xZF#dIQU*ze35AN7z`fFn z+J&T`X6Qk@NM)mn@=6C9as+Gy5u%yrrS|VUnsFg*G zCMzI*0wnqoKX=440BGA?sf-O&{x}c=3NpIlH{P2U#oeYx9W&gMdeo@v|`GgRo{1;C9dDz>MFwu5fp%D5M&$2v1ZXI4ChU zTi5Xystd@wj16cuHH%CEc0u{zM?}!J>`DHz|J0_4k$7d9!2DwJm>;CO|lNg?9LkIvrjYc1(vNtb0?2)OtQ)q<1= zkOhd>x0~m_gT~~~Zzx1wlzdb>w<~L`dM5B_a?=R?0St+(_89Qs(7%Z}G~oSyuLo=q z$SJu3Y8d*G5)qEPl&zvkL11{B6B%9*O29qM-cx9w^^q|TKQx3<}?3(`uXM_a~&DihCimF?m6m~CC5 zx`G;dDO*)Tm*;L{6hww!SPB+cUK7`W&zu-1 ze*HTlD=TkJGF&-mtv+zmVK4w9Ajd&hPMS$?+~l&)#8fb{UAZ)iY;BbBu*oG36e`vOp=1X`Gs>F^@#WLB{vIp```d?2N&u;`05Rvacc|E38?8*DT`>a;7<8SHy3;(~C#8n?_nJGvrGn-FvH?p~hw^M?X_QExvL*1&a)JxlH$BQNL$k5kn7J00O%Fvua z*d~GjI$D)*$s46i4K1T}5iqSd?h$)RJpw7-qOOe?E+?Ni0Id7Th)^6qUf;t)xr~ ztPw5g)os4Z9HB7CD>POZ zgiHx!Q<5&R0=OQ(Q0WdZ^az=%fB(jU*Ckx28-V4&srEZD!?LK!Cp7keCW*Lvf8CwW zcw(lGpHpd_ZbQ2MTclU|g#FLZ6SAy%yc><8=bS5ARR=sXRufeqS|xz@ikEo}^lq64 zz{ULC5s@#!Q2nA3RC8pKkI_be>Fqip6jOeoz6jyC*&6xI#CDG+^)lxzx(jdDzK_g$ z^k?zo!tChzW7bol+-qGZOh-K-d!20~GSwtImyIVBr~{E(5?y2}WNZnXrGS~u0QnW` zA>QzA97ptjz9$@7!jb^C)Po-YNz|73EluMOTUIr(Uu(X-&Jz^Ha~&@2sC`jU&$QtA z9i$49WK#k;0mKIX|DRw0qV&_)fE(Y1|F<6*h!dYGWa1?_{^ux+6BwejFI~Qg(L{z# z5N3tIFRWKQD+U8vxY129_0+3o>8jO!&_C4c(DSi#cfz;~GMx)rgc3bya+5^c_sFC| zCV;8L6>LlC=LFCgpQ%9DiU|;Mv+4ly3d?*ULV8%4szn)0glSBGGojorE17)e9mQSd zDTU`se*W|3?QRG7A{l&ESAX*ae?7{C8N_p@Li`an#Fo*y3<}@?9~f;vs9M^|Zic56 zfY}RB2`oMVz7$>O!yvaQ*=#k*zO<6My8mR?7oJ}PJPD8AOX%5eV(BmFo0v|D{j5QG z8GkS_Qo&04S>LwN)Br_i)WN=&3gN{yt`doixEqbhIi{%Z_O)nY*2|c}ab^v|ikHbJ zxoJwo0+X6|QeY5)bpuAR#`icJCxo<7+1i`m4M}LoCHF1cm+2j*R8;^^PAUv3@9KpK zVhKd%GLlPR`CM3u0;$xd*A=R;Q|V<|`v zy}b8uB#t?ixagKVv{3Q)g^V+v`{95ymv`fQJtZM5tkRu4obcB~cVrqmcX!+E8 z7O=No#sV6%Y{ZyfduVq!D*L`J8$`a%NYu~J*GI<>^^XL+{*;DNtvcfO!1w8+*AeeP zE6VEM>BOP+=b!Gb>1wi}>en>|PAOC=+2&! zz)HZ79GSXPc3{N>OCTxw6Y(s}OFtYDI>~5Udg&a>b2s#q?0!Jm4G>dW)3XaC3ud}5 z0Ine&11`*EYp!r37q~rWhQ)7!ghCl%gwD@#%LGc^48)5mM8H1niSOVj;{DAa|RVwL~-}>~@xlf!^PxUn6J(>z-!C zA@+FPAgi(mOB9e;rr1b85FxiGRL07o3*MkF`OUIgWXrC!T)IH{6Jb6=SO@8M;}HT- z@c~bE3mjFC{NKj{`0X|kQ}7;Uw%z+@xJu9yx%0)?pXXG^qb^nS1g+UnBp=e$%F#0Ay841j47Dwzu6aZaJ1fhoJJeSoMnf1f=t#453yRN`n3!KeScV@@bW1lDR{WZC3eMlcT1pYATCl)5+9Tk*mP=$c4BiU`08P=!NcG6YVR}&yjY_0h z1lbEl5)NJv@C^CM30h?gzP9^4zp%O@R1Z``-Nq20ObFYD*a{I_I$ZaMEN~8H7KSyS zouv%W1%=T6JzvIb5rb??wi!3D9tMgs+a0uGXK?PFpj*oJ3rRHzQX|DNqRS5Q!4-?o zEUyi44&#%Z!iarD&#wZ%S}EkTs_L&1-(!Z+E#q@3&_7J%`;hw)snAkFw=ASu19uJR z-&bp)oGI>Fr+d>JUd=5?kWnnpot) zJ-`O^=kG_!wkqFpQda zz*N;Q#w+Cd$LIrFLr$MhY^jk`DLsPROb5_{>$w#ZCVm( z3KF=(oBhHh466|~8L$PIRq6vEOYt>`qMp7SUQX4?uSUY z`rz}yjqS>b-iBimz4&k8^;g1C?lVjS0`Y+$rp`@}GQ_SUWbe`F;mH7wOf|78MN|SX z4vSO)zz??LIKKrrc#q&R$};(Y?6F#AflK#pS5TMmZPa^f7}Drj64W1geX4fL?dP4l zhHi<8w<3@ykt;lAo@p~u6!176&+kWZlyDeS=wSn7N&&Ma!<8^q0E}xBP<95u;5rEm z31l=15)awPrC@YTFPONfo#cA+ z2%{5*%G^wd`BWQ_(X@J!If^SJ2*rvQL_bEI0A|ksC8XB@H5DLiAsi*5QqK1V{6alp zNvRg455(7gp&W7;>L;FL7BVb!ub$I*GT>u-A>-z56LJxh z6UwCmFZUqBD#wjbNGFca0a3sv==>1|1tgKA2uldZ%LTOhg)*zJlTzwcqHUU5*M0+N zol^YPdGhnpKl;>n|KU>dj+EB!)0r05p-#E7{~8K}1wq5cczz)ZOEsohCVC$Uh|7tj zfK?aLD}i@|K$V5i@gh1O;5*1~i0fpLMG^7MpV%V!KiooxVB(}URq$AFxqu0t6z9^( zxC~#ovD3`+TjFDsGu2BcHy^PUD2mLMjmr^hUtLfozE-h++V|gWlY- z425hE2}(+q6oLN=(%3oUn7ua-@APwWCFCTwSk8sY|M%}9$CV6LiyzM5>e4Kj-OfgO zibCON$I$hY3}RxgP1@F`P{AlR0s@K_0qDmDd;msITErk1F($$LpzX+Z@Q(V~sYU7? zAyO?8L;2Ju(8l%L6amFv%zhoN?HqSd>A~KjNay-DTi#R}t9z^$)p)DGtTf#L0~z~R zHrJaTVaYvINCQeB6UQTB$ufcfYh47@0YU+posuArz<=VO!gDijjtFx1S}*^N;>ac6 zfbG14cUrWMdh_%NzF*^jEfy~d)MV)f1s2n8M=q|r5B-cZ=F@rVqqi;v(l1yRrif_3 zyI}#GkuUG2UPdUS^0^QZK)Yay2{WK(q@vM1&77M~?Y(B2KAp7f$>%3w|DIAylk~f7d!qgC`SHgkgTcv)eCGg5Mc`D8Zv}wA zmZ`HXvSwk4SQ>DAfDu~6s4Sw1TVVMN0!fg&LJ>v8;rfS~zP_rVl?p_sU8P9u#4V>ku*c z0~guZ41%LYY167IuUU`BzbxJz1?CaJkcZ-ebrvDJ7 zIoU;ygSl>p_k8+iwose$$M*D?qLIXPw^eKJZ``5fjQ(%aw#hrXf( z%go5))0d5%x^BKCtiD?y(j|}i0%7k>-Q#OgLvupw7D7ZJ(A`Bq>_RFrhip^4IP#7HGr?DY$n^lWP!1aV)~Z@paKgywBGJ1z6MfOix~&mixfefKe7L>Q zKA?F~f_0vDQaSB9!3?`Z^w~`~rw<7h>8lE1@c={wkjQRXs01%5ikOm)6N;dv_Y0p# z0-rBOWfS7%IENWH#}QeUe#iFS_*0v@Tl+-)_#PEK-B#)FgZmpx zYvsGq+U~d_HrJOSc)v(V6 z%3hX$qfy}a4*?Hwm{N!$g6aV9Oty%Awvculzy~-(MLHoM2t-4AiBQV^!i$HMtY_&v z{^Y=@OR9g(M;KkOZ>iAC$GxsjwcsUnOhRRbi#=xIVMx#w$$LY%#}k440i6OffXFP= ziRd~-%g!1&=n;W~+lX`EXhtH7n-$9eo>jg)71=T?uI4Tkl0LWxP{|0P0M>h;TGeM_ z-r7{ICa04qDp7fPP~U^=HGZY?a|q*@D*75!S9y)DJ3uApgHT%z0{oi*P=rV%OpPz0 z@kgLKAW2a|wkIGIzwfm`I>h4hB1bkGhRBKE5Jy?fM&S!dRikf_vQK-hrb0+w%Pwx( z!UEp=K|+a?sv6204$VcWP;aWDE@>>kp>BjxX~?Js0$oI{8v%J^fQGVo2|NXql4x+r z88{Dib!FIQX-ZMfr}`Fp&?)cVfdW%+_Isn7K(2Mr<*?% zOjdRg+LdvDib4TlPorjeO*-AK$5}HHZ4hg~c z!P2kM1qvA<2jtp4fmL5lw8WoX-Ap&j-(1r6g}23gFiwi2!PMFd}0h}Rn2X` zO#A~sTYmWR%A-TyltxFoRS*X*E&Ps2@jA4Cms&Bvt}hPo1|Gz_8Wowv=o{-i>efgC z8kVu$QQEr+=pmT!2C@Z#uY}I$(!O&UM3_MUk7o%%H5NdQr(B7v)nV2dXRkaTsn%aq z#Qn<7=*K~Iuybhy_M~;)ZywSAMcy~Aa{;Y1>XDSQEgoW<2&&mlVj%rH9Rx0D{yBuw z&#)DNlXW_=kQP-Bk&CF&0$`@VnXeGG9_98a)s|VDaCo}y@1c!K$c$?7I^~1mmy}w{ zR_uQ#2l4XAgUch4D>7)k&rk_Le=fz#{yEw<>{dB^5eOwj&~_(a9l=81&?{lab}2;2 z0TyqDPK2rU0-*3hWC;lGWMbn?N0l*g&tEUMU-}PH+Vxmv*!4#pTGRigt*1xz`KD7j z>2kfzlMl{)E^FLj_HrKq*{*b~wzE$A1}uz6aa2$$Z(#ct;j)%Z%BaLbCbTFAsNM{~ zqh-7TU}AO74A%5sC@<;gpDW+HO#VsWQccp}=IdSPpkm-C^JkAKxV@onm1Bj$y1T2v zVNO)MO*6H)E!L6{+4jsxN*iyj+c z+qMv^{xaONmOhMtm*7diD_alIx6BkDU$gu7%Bxc&&rV2^$fcCX>wY+TKq_h4J zFI)Ja#^}=4s|JOnKhN&DFQAuHDSXe?w~N9P2Tlg$KzZvu$pZO00j|J-VJCo(I}teE zN)*@$q|uJU09_?Wln5wY1RJ=2po~F^JgDU4Y-tg0 zoWJ$G5;*JBaK3C~+ObO&e1ULqp4G&XPGLXcw){V$z62iX{QrM)Pm*DTr4<_2=E_c^ zLqekrhG@4O$q{8@upQ_a!?;NpLX;RswQ1APC}jqfBekxs@kv9}s>qRu$?Wg-vETpW zZyyhBGN1SRbw6Lv*ZcGN=zGvGB)fQ-_}sh`$XBR2-IYk##2oUz0RVyvoiCPL>7Hx= zkEjun=H23r*~I}o?bZ4rdzV+B5DsQ*jp5@?!}HRde&2SF)Yc8D49wCHiCM+=*%`e^ zX^@EA=igvLSbY>3mTX~l>DNg90_bRoCu*3XlHkDAJThMQc?qnuF6@~M*O?v4X00^e zTX8FX2Im7(PzVl{9ivLMBV=37%-{D~Jx7D`2v#rPTWVGdl$0>Q@gZ`J#IS8MXO=cpBHs;BOyGj>8Ij;1*C- zt+M%x^M}vpaG8rQBRT`pPKul6*j^+tGRgXxFNCT*+3@u@HqunX?vbqn^NJ$lsJEa` znG@Id(+LAKi+RMB-vva%Plg1UZ+$Ak1kIYB4$ao0ob_|*%M0wh-nZer#TmO<^2L^_ zL+iH@TxJ_7mqc>?(tka*kjoQR4$O1UpPxz~RVYbM^1Hmbj9W0unV4TVJU}P((ZYG+ znx@Za$tww`8cNvlSZ=Y;1aovnQsLTP|I|fApr}@!_P2a8|41r2>Akphop@=7ghCTp z2xjG+9!@p@Y(ftfF?M`jz*;XgEF|?uhF<}`bHcEn4yU;48$>qf5yN?r{RTgyyF6_J zZs2w{rsR%_cgV!{4i>tA!jUUwO>g%mdH()ldZ*h1YSY!Z&TuN6&Emd!ZnffL{aeah z!>P)&Z9ZgcdR=E(Y2-H%4IWhrWQWWEjmLk*ZxEu*gp+A48&lwGLRejoY$A%siHC8j zkEB+hYLc1yaGRoH)#0?px|a|vs_&%{^0@AjK_W)q{~M&X8S&w{uE~b^B?*wA6rPs2 z5+)`HaHoKr=mehF7B%`U0g~=mmf%<&7MkzAdwRz?Z^_FOhaK9^jOVLTbp0&WNI!dZ zG<9{@#N!w%$d)ApUVf?BznE!)k1ucnY?l!DBX93S|I^N3t1bdYg)N*Yp%?-ygg}Z# zQ3Ya7LQG$Zwe@%iMt_j^(eTWo)S=FM54vIlr*ApFW>a)qE~ShZhE<#U`i;)a`1Y}# zXmb7G*zh}*d32TnmE`+*JC9m*pFy98Tsudr6g-Q|qd@~-*++%GI)TQzU;5PA}-E z^$SH?hQ%6H;}tGOz&QHG!=SnzH^#=Rvc; z_Kg%!NcSl~#e+3?C6w*+;z-CClXK!pzF0Ak>vx}awP%MdZ!T8bzhN=ym3t_@RG~?D zX@vRePmb$^{A5dbu=#_p!KAm9G5S&AwFREE`a6pVpwx-?H-v}aO7mTeMmmp6BlJN#Uk@I4gz=CIU2)x9VCYYg%d0~>515w+us`ki^=qkq4(V6+mzT9K}7kCpKZThD9xhGCstnI63v$UIhXyRyCQ>J|ujR3bt(%=2&J1J~Qlgb9ZkUyK-}9Dw7% z^|b1|v9uB-%zo*f)(cKt@&0qXO9R;8eJOd;pGu2gl?cmM(d#6{1;=a z-VI4KkE+I|)C+(%L$ozzb! zv8mO?VG|OuK!W0DFRaxw0m9__Yg{-ce`)HM)03t!RfqQ)ys$Yo_$0Yx;EfVx}`_fc*FuL;#7xP(?=S~L*@i|~Z9 zYk~5ya_?W*KIWVzzcH!*FQe8+r zo6aky7!C-{5D{}uWC5a$=0WfE>r1>Z(_bP!c=D|D=id2&kCRtM^BfC52G;&imUE`} zs7kUwUpK~>Q^r44w0wJe;GFsKm!Aw?df95&8zLC|3W2{sWB@%O_jx8p{M4<}4C9 zFeuB<3pHEm=nIeX=7qb&!4WkK+n}JEj{ucy2+2vC0%P*SeF&3>L`p=rU#bc2y-f$_c)I-$4wrljtW?iN$tV)H)HY+o=tnC&hR z#q~iEq8lRiym=7=(h`F&hR{RM-i{%lU!13@`>{NL=6p)fV`$3`CdYp@Ya)~^2zZ~} zYPow9Xo}{Gw4X83Pa8CE^13#_limNtyh|1A6leu|>d@X7+vNmv{Th(7(AJeuaum#} zQMe2&M8hlaB{*3m{?bSDc)*>;6-DMyWhSUuf zizeb}obfz5Z)p<7GV4Pw5N|dJ<|z|>!5FYbgZM09t^ukHBtf2Ni6>^xi6{67I_l}8 z?hLdfU{w{R0^MF&+*^#Ye1XlN;G(iPUG?qW>1+yAX$qla(E<5_Syl7YONY2o*#^jm|%gWZ=wmlc>BC)l1(Whho|n}dxU#tYM*FwzDIQjLI-8~(z)F~Kz9BBVolB=xI;adoJWqW;FSc|CJKO7 zfdj(gddPlxRJmgJ2~>}fKw_g6r~$E%Ak03Bw`>yJ2J%yIT|n;*za3K%hi0xE6gKaN zi5#!l4lv5(e8DNRGVAF3Ou@^Kjr96Pm&s}I&)Yu7%dvV*Fa7!y6D0?4lmNPZfI`aE z<)IA)Yz)nl@IPWE|NR8CUn07y3A+_N4VK5S{kt>z%H@O1#M5Cmiz0eI&0-FjoaG8b zIInl~L+3B17fv?iE7B=kUtwjjp-=E_eWe0VCl{33uP>$%b0`EhECQ*C4%Xm_fs%!) zhyH-pPax$e7?W9v85RX8tRhm&U~Me;XqrIOx;`5H&wyiXyPP>Fjf zhA*GdfmVkiwOk@Z6L*AYXUS;j^s?ttLb#MrHiapQ>;(>t)NnsZb^Bbwxf1G4dNrKT zMGScE@Vnhmt|lgU-f>9W0$XS-wrFU$?@K2YGwJgSx43lT0F~%NgLz~n^c|3>z#?mwHN(gMM0b#{AkwhAah{#yucxKapZk6QJsyL3XDbG8&_!&?1QE(6?bZU=^!KR6+PcR4-)bDTsXZu{CVYw z1xMihrW0=632%VpGZ`c7Ud8s+Ko-Y&-tWaV4gM1Y6j*}JUm}zsxB3Hc2o2g7NgwU( z9E1jcf>#PdJQ1WFSmt9m3!}@z@VX_Fkq?kBl_n%UPm@mU21&g9eP`@(Tn*n z<{PMdyo9<034_-|$^%ZhR|#4)9-9v5G>jTi_Yw>;8$?V#=#3|)-v>IBz;@D=B8i)# zyFO#hNN_?oTwOYv^F(9tqAu5)p2rY~{N~C3qUBC7T~G`w z7J(a6DiL50=)67vpeQj2IuJmj>}1|ws7xTl+ncgt5QpNJB2OCVlQN#euE%`cKj>^= z*p&rei#VAv~UD=1YvMa zJVLX=D8-7!46f)yKQ$(gW>~_6iXf~Mfp>}Nf(4iYa51{76l!H3=#IJQf%-}V0tV7D z6YiL|izgKP6o)LKqKpT}@UlfvsCtUt4GD<;bw-F;Ff0kI&x3)Ah}j^l z@1qd=!D-=Qpl1-SvJYH~Lh3^%1)ov7fZ4#8Lp&8^*l95M^Nk=a?vCSmN59O((jpg^ zLK7-o#(AClK(-i>*cf689CDH$FrYB;;k6ln5x7YfB9h-Z%Jv)WqY+-UqouJ4JZB)V zvLAXLF%#AiAd?NxZ1NU+oZu8L+UgRm2V!c(OA`eh_Ef_XM4Min87G=(6ft%{QPUf& z?4uHjXEMPO(J-gXqczOK8a#1yo;!q0CEUdX80xxg=(r6Q-L#%P`2C z;O^f*$j2mNa^RJL!5?RRDb>Xy(AMY3xz2_<5tH{Su3yZQEToputBWa+k4NW3-Mq<2 zkPl=!b9T61g_6%&hlCf~6ZmZ5CggDO88LzDT0+kR&b{I5I_76O_fz(dT2(uUkg&LU zBv^}5{}Mt9&eivWTOt6mpb{>p#E;<8;Chv8$_^ev=XHYzL&ZVd#$-Hnad~e<^AbnW zznB_TX@g*qcWp4&6~y;1YwW%w_}V0#nD^0!=PgsHqlkN_Y>9&dy;1}e*aEMITKTq{ zen-rJKn6;T#|B+GRwC#@#wEVcK!AY$;fQZq(ofjxPFZmkH>93-b!q&*8QdyaZpwCt zy%8vNj3&`|15eSc5NnX5R!k9q0sOiB&vB3j!4&fgl@J^KVGKTk!Y=f`PC_1J1L*mw za3Qb;+^H=Q(HoE(w|I)!9BH{DHHA(mzFj?Qc;%%(b%ni@ADFM~(fv1YH1W4eF`akM zWaWWk`VKMGvT%N%3Y}Dn#PL6pv}vTgGdJOavjSu(ham?+?+cU=y=fLSCHeto8AKP~ z(eg+WE`cw z5dCZ)3Q`Q&6lgZ9=EULsG$@Vref0Vg+RZsJgAcO-F@q=S|BHQFiS28j?O05YMQ?s6 zGNzXkRj|0rU=((6!=B2rUJ0s=Rv+`5+QS^1+7@8VR8QBg32Pgq#Tr0H`-Cp+GWQng^3fL_g56 z*1s63-J-o!s)_-;A7|*i_ctbX21v#GVC^hlB4H}w_YXkVcxdxIH_l z#Q72C9vZ3BEZa6ePUjQ6PNBPTpxW`N29qe97n4+N_S)n6e?0`XiwT#imaXavbe z9&8=j&^{Uwq$-XC?LZYlyAJqB1Ck?khDojuB;)o*GvHX(r?c&}cn?`0v!c0I497}V zgQR5VxVnEHEtBp-5>2A{Vf6fj?kjN|Ps}ShRWAbPrBs7|6~nc`;IK%@XmKP1;Fx3r z+7;0RD2lz4_7@U)!-?17zqFm-)!jfZD4`edBs&DuJHh!Z>~7*??m;${68zDy4;XsB z_ykm_{o+aZUgFMZpo0ey8$MP-%4O55`{~3IxQh`@{v!JPXMm@49-_LJ{-BuYkw!vZ zPgn>R^a3maXL2L^hN!r_(OOl-h#euNXG!#DAO2w$hy9R<>ig;S2gQ+n@KF$n>up#< z9i8i}E~3go0UH3)gd%_yprnXFUEPDQ5@;%q`d1#UrbfR@4>CU=k?@yz&ALfTqR+au zxxuyZ_Ui}viAX)ALP4%s10#A#*A`@KlEIyU2&RyV{Udik4uqnFfPLo0 z(Fg@vA4ux;ux<$zA_F=-Iv<2V%+Qmb0&(InxL#NAXiBS$lH>|Z1XwC7uxonUVJovL z^nwb7`|ej45{RECmN59)B_0o1Vl$Z&ydN(i@LU)TfcEm}Hy5EAQ%M7iXaJ|B-Bch& z(Z%T!aqtxpT_DPFq44IAsv#mU5ILcc_*sa(jLa-(V-7(R+8Hv>Z+5}3GmKFW?Aymp zFk~HoNc|V%HxKp09V#!31Rsl;MBkL?btkOqJT2SMS(k!W66gjj<2Qm&SP*T78* z0(ia7ydFAfrD?U#O0}dr;_euPSwc~9mm&RHMvC{Hn0C!;5iupAa7c7;34aO2C`Xyj z@3MV+>ZVv&Urepc3%d$Yk{3yB5Kqp+0=!p~a}>0`ONHoG_PI|$^2#gd3Qy@XW%-&4 z>%WQ5Fd^fho_Llovw}p=PXlEK;C4i!7=39@6giJPYoHNlztZQHZo#JEw?CrI0{CAZ z9R{ZiK3HQ8VZwFik?r$hysj=hUjw}!LZ8KLU7_lsm*Qf&bY}rMMVg@y*e;g{z5bMA z9rXOZz@de(TLReQJSx(80fl8Tz?_*_nsZ;0bONzhdBr_E502rwgV7lhWa%VqrvDa1 z4GXJl*zZ0$hep=3kzjT+rMfd@us&BT-Z39JCz{+Q`XEAP@q~hYs-o$_Ef5~;1(*P7 zYoHWBv(i9?_KG>*$?Jm}2tDEwoXmqxk%8_SeiJ~Q1qk1(v|_X*a$+9jYxqoCA%$@( z@{#_7*jL)QUBHY6m@pyZ!1kV1Bjoo|ePy7*22nLIT+q=)&Wk=2yMuc% zB+$mej`*T+zF5KO&ou+?APeMu(J6y!Z-v7TBk$2AUr(V))U2SZet!0e_nrL=oRi~| z!y==XuZ-s5q~$k3Fk)AqpArc-Qofp`OOVQ9D&dvrCSOzqEEJpuokN{$exl)PWP#Y* zpuSQ7*-`|XgH&L~c2aPeloVu!bG>(n&V;}W{jD#s^6P}8JOg;FOQ*d7bn0eJqB(XT zq1T;0Pa&Yu&l8~)3!$2UHYO0@agfM)z+up3fh=D|!r=IKp#J3*Ci#eWB>%O282t`^ zj|`8(r3r%@5kjBK*}KwjX$F@~lJ6snRI`FS+7H2%(OxW1+P7(j{-OWOEdf2a7^Z}D zL4$a_^vv1C&(OtA-2c1;ZqO)lp%-|f*9RAab(#D;Ngo9BTZ%3Z(Pd*z^BAz7_YL6! zdIOJAi6Aa!x+#!A8s7G?}lYAaxSQ7a=?ZH>a)PhMwS0?2O^$x$E zaFHxEKxe=saM-jT_r=r!8VL^GHX=-}UuvB@>Q?t%Cg6gSGZZ?vHA1wkCMYH#40_Zn za@omYQqJl6b+Ie7F!D!%i>WwrOdKisdoa(%C8U5VpzsDlh(&>fJUS1d7!FW*=rzWn zq79K}1}o`c0}!XatzG^wSOJr#B7Ii3q*=%4hJNk5D!l^AI!Q zCGbN3hR^;r^*Jl9pa*sv!~iNH@}PdAo`-o+KAjdOe9}2gK1MW+(%_Tm%03gOl33%3g_n>)xJUOE|S{T6>N6rbY zODG`WEeYBpiEqOBON@GFbnwUbm-VT4h2Q*AX4t-vB>*(=_QJ-YjL=8}6hld;S`odz zgi1h|U%*W#_}yp09DFbYG(UCzOY=GLc5(?kVdWgG@zD?fEJANWsn35gCqS*?5bmNg zW^6kDjZn{b>0*H}4YK*0i$#Aw%& z!&;#)9WONaihzbr0bs61XpsW3;C;dK0f}=B8`&m8#tN23pL#y>yTjrr&@am1{DSw= zE5Y8E2zY5f9>4p<0JR>#Rx#E3z8G5RtNbpg#!%sy5+?XiEyi9Bvl|}T1N<6DKruvU zL^j>bfIVB#hcSR~r}EO-KrTsI@zjP8eNThhqz;!8K9uTWI`N`-={0z&2tZeTKLwQo z7$SPZ61aQQJlr}0t_nwUA7S)W;E7dI(kuS^!k}L(RB*a_mK*K%*avt7{s9lRQdj~1 zz619uXmB3~-M$BdQzUd&gK51sw|NW>QPVls50!B^u#lt^Vq~0z6F2=rW&b3$ zO*cO7dD#5UO7z`YTmR7*r*~(NRj#)aw@cfDWFM+1^9ZDzZQ1Me zACCDa3D0=y{!LDEz$NLe)RV7(eb_pguk@3S3I2f1cjcU0qjokI3lA4f&mmld+kwfp zE1frN&ar!uC0FBoXx}DsUEw*ufQKiJzt8fBY1#P)S7Yh?YI~<5*QARIwz6g4qxL3~ z&q`C-(^t4c)1%dU|gkI@-*w8eFOT$1iou9f8K z_tfO6*oRS^m|b9gAE^)%@{}v5rCmo;{d}W9;v?7f^1@Ef7?a(JP{EtH+cwtaG)>q-j>w6<|{q3**bw%`B$a5rixN+pOqb(E8JlB z#+(dw*{w0L=4C6K#;VkU1|PPsN=r*Ss}^1nv+FM<_wo&_y|?vGw&Je%4B+ob624g^ zw(pIC*U-HIBZF>G9dj5M{Brz!`tQ$**NRb7l7G&>UvL>^?mccd*vri<=jJzs4Y{4f zXy0`n{-E@Ru=81-NtA2V7zQ?hZ$!Pp#2KEX4c|!~w8LtR4VDoe-H8V|!1US8={f!6j000hfiS{pb9$Z^w9M zzGEgae{B`3uXA`PJk-`z9y-PIQ=G90=bbTcf6bSDBXssdiev-)K$54uZ@eeW4F(P2>7$*rC~V$0}o9mBtWge*|RW{$%V*qc%qO2VdLN^Qqb8;q}u!jp|+HaYk8%JH;B!_YIZ6)8&piD6?*lKQX(q zGXxY|@F8Ja&zlxl!Q8jV`h;7kcB9d@c+BO8$7Q}e2N}Ikt%m1raw@5Gf9O1vKalSW zFOOY>tCjXZsG-55)pEUVjEQgG+y2fbbh?M<6Dte{RZrWTG`~7)kq`sFqI=iG*#`d9 zYq^l+iA(fK(t!^z7DHhG7aD9m4(1yNO|+j+=8&I2Om~sf|0I9(x7sgPt=eQKbJc1-|N znkq+sS5LwI9q!2bszdwHziFYLPyC*KFkZ>kiVI)2Hze*Q*DJXt)ni>}jvXV|>*H8n zus8UiOl{7nQ*otRe)>#Rlyl$>G>BpC1G|RRl_gnDHtT~b=OSN&^C35K)3hKAO9tG%uf;G!o=CU!vS|d?Q9OZ zt6$l;(Nugk7N~qI?Ut28C1tH zSo8w$Sv>{nzRdEoil3&ZEYg3tYnv7J)Q8`{Rnmg{Zt^ATfR>(RXe#*65yD*q%Qr3C zl9PtXPcm!qcR_^H7^4#)2*fvR?M85VK8U}3(JRhi%4bjUO%SN}watBtHvv^r4Yts^;qU4(DPw>GrkefwDGBS&FJ% zB7J^?Rr)N(6+%$)kHZOnW!?)673^(y7-z0;%Pf!E1PelPFxlOyXc;k{7VGhgxs|%i zV@0VLFWvD_yXUzTTID0vt2S?0z1nTpzy|G*psV`yfLcqTT0iGn;?Qs2EDZzW+A_EI zF{Wl3kA#kM22n>3wL3gS1<9{^bD`yW&xIa>1OB%(hq$mYh9Y?wDnq~Y#E9Dj*E>5cq_a0WX8wzQB-=P+>P6k-_+Lo<6FgOWY$XL&tJ{baQFdl z-TWj(lWYE6S5AnzqEvJ8W=q$rl@3F9X;w~zgp``ll$zglL+yGJ*5|$+{Xp8XYW+@o zcju%>L!FBRZ}ny~%th>L-U<)$w6m!xjoDzwC+{URmpw&k0d! zhME?Hu2>hM(Q%>2UKvw!Cf!soRgXD z-Ex}$q!#E%n}=6q-`(;sty@aT_4lDs*QWldo|pO$G-RQ?7yjPEi}g3k{yVleR6rRQ zYZuFX!50}t8xa-RxKyYCpc$+5d=C5dMQrJY%@wA`MQk`uc}}$`ai6o6m5OPowSqf~ z%(MG*v(ARqyAS31XqFA?$jd$7xpslYzKSc_r{|p1!`AnzlX-FgMG)!vJ`OQe(NcS7 zAVr#RTFFb+bqhLMOSft#!}c@nTq~kH0z8rfyc90wkggOPM1`iBo*J6^szW+RFV#F1 z2or$bXIU~C+8*AI1BT)E{>(5nQ`assimK(iudA&UsQgeqGJ`L&K8=SGnsq==ndF%% z)e>5kvSu^(@sYJ@Q){wwE}LrT4>@O1)Rcabw!f*DwWlYP7@Q?j-m;@*m5a*H8ID0L z#RSqm!$+^5x)lThk_BX?$SRaGzNfFRzfKkcc4S6%IaQB&RcQ?GNPruFu_J#zi@ykN zG3t@gvvP_bWK(-UX&=_lz9J{1-trc8^bz|Q5%+d;(1?a+%~_dr%~Z~R80&It6sO0m z_hjskLZ%S4lh8kzwarv!^`Q}0e9Ilv6Za1$v)ka~lsgb57y!dim+tI@Yx=ltLsMcD-D@a%g{< z^xpezSqE%d?kD{dfQguZl+@x?bWuG+248+RG@xi_S|HgVYtPk{=M1vs`qyf~C?|e= zh)CS3n;@M~^K;NxE=TuxVuwA)>eowEj?MRU?;2lpb4p9g^#6IeK!7BX*srY-xjU5R zY_EQIUl%`}Y3a&ot}xTkR7=~r&HJyEuv8mDZljf-bd7~}pN{Q;gXRYgTBi>=UG(yD z13UxuPFZnAW6UlwTu71)%c2 zZn5x?knyZAx@)HLf92~NhrZ^*h3rcPWzJ_GK_-A_xsRq6MXa=S+CG$XX@h2^S0}5v zUdG&!mG64(+O@MeUioP(xx{@2HaexV3c9hX(1}2MbqDQ*m9aPmWx2}w!d~?hpyM8A zD1Y$FTCSA%&#~imc9+L|bnr!n9-(NG>47wPV3=;cwg@0rSOC%Wfkk?>jj3(b>#6%X z8n5TVo9IwjvG^1Juh=F*g-#r*si`>tlf);`(6t_~#h5!eD6%p`@}blAu)4j`;Y3x7 zRiO;}So-ChbIh?IPnVWRHca3ssVL!~g-X&DYaD8Q2;K@i=i#HDn3DGPF>W1sgF?y9 zgUy&;`7%ms&l&ScZL@+*$E#V|kQL2VEEl9&_2Ka;vGQ%$rj5nz;lN==PhuaAk@Sz9 z47}yp*@HHs#u;V#N?}!^k~(JANk0sEn_s2Uvi#L7BzKgPAlo}GV@^P!Ui&t}p40P( zSR?01VJGd7_-A0tb*kv5H;`vH3?1w3yV zo`X-Axcu4Qrk?4@9iK*d2{d_|kiT>fZ7dEDL++lNa{hFojllxbu9n@7e5 zyTNhjBQyM7J}V?v8S|aoyBW%(knrE2ru31%yshn8mGOwq&XD`t^D91KjEgR}wx2Uo z2hgQMg6%h`2Sz?!Ea)zes{`%Bdki4tAL&lLXu1C85_$zdh&H`j;5q5S{Hk>Xe6rde z7^yAT7}qE1XjKe3XD4v;|F|3wvX9bo%yy*_D?}Y_Q}TV5yCw~X;{k99FR!GoWm)`k zpiA-r%PNN~b}R0FGYf6m>)2S|O$A;glIPGL8SPzCK|#$8iaM6{zGekFnfKc=6_51r z<+;7Xf#U+-zAy#b4*TIT*xZz1uh+c=06^O2G{;V8)_Ye=A3CIy_0&5S=a!zHe$LR) z(A-U>x%Rd*x&tV%8GbYrFX#}xs?@W~qe&h?xYK5Ozbb53*ESZc03<%-r+jbthYaf2 zM&Y{8$4+n0OE%dx^+8)lR$JHVT2*sVQ7s;?E{o!cz)+rFS4CTNtc1;$F_DTEDFIy)ErO+wiuBocE0dH>aQk6)|%F^(r_vaX*{q@w;@_UIP+7DCMSq0@;9x{3gu6XI; zp-U|R;FIpC<1G^uZXaDPJg=YT^fKAgbL&p%E&?d`)V*YUad)RoZ7+Cs#05QU;+~^f z4$299pBfjkD@1r*Bn{tF%x^*R?el&!TuKmxodxF5L9j8U9;pT`!eur&Orlt zl|VLHd0@L9z;-m2ZUaUbf?DNlhzbQ(k^BVw#C2%dfd+EBIt3kiJ>Z+LYZypj3ifHb zQ%=8rx7oNMk*uDrdJfu~=3E8)Lv8Bn>Y3mpfW#b=Ib*)2vBIFjlM?OrN7Lnj-25tw zGa(WdN?hiN?F#C%s_v_pEf7CUPDii*~1|;doRd*>mCTDBHmZ4=-?}}U} z_1Jv>vymws+l+$+X!;a>b5K^}2!qfLc(50gqd?h6NCT%F?O4D?Z~pn*Hmxz0sI48< zsZncAZ+y4qmz7Dusuc!WiQ2^wd}%{fHi4nJzm8z>Cwq9lXuI*mV`gV7I1-AM(G(&# z34v`C_YYS%w_Ux<{bwCwt*a|1h7v8^(j}jKh$5%r=$58;Hq-e&>ycM%Hr~Ph^N2d2 z=zD0^D79?Va1fr1{azUKV{#qZ$@_hD_6Yn&I#B6a3C+S2v%I2Xx?|32l`>x-E@jRo zRMuY7SYM;2uc!Z$=B7tltV1=vYt9i2*6vE(O_tk|BGgKif`{9%J(UjS?=y5bY@nHTxQBM{Y~uSBHw%iC+Kvs zxX{p?Xo52qAKOxJP=4p?wx426BfKhfHb024B2aE0g6Mh9^DDJAcq7=>*1b+fSA6~S zumak1lXaehpZ@n{yV5h0y}recMN4nZ)W0dUR*IIXWJoq&N!r|&G_=s7kQN%+sSABd zLWP#a#w%mJs~6Uu>*&ofWIL5PJzlSpo0|^r0WpOBS-lgN^g=)4!fUK60dfj((vwvh zAAqNN14U!jdaLpmA5&<$!hwo_CLnaJWldP*i-6&j%m9){lXQ>UOCkd6i4bX1%6u zH(9e1P4p^y)_#f=?GD0Oi}bjw=SNUKUp6c>^vU_x^<-PTUi3I9o7EdR1FD5eVY17} zO6bt-mfjNJnt>Y{qHKJ0+FCKXP6iqQ!;F-Flv?WYwqR9oFI5}mSqeJxu~Sf(w9qUQ zevP#iV?YF1CWF(bZ#@SSjN4v))2N=B1oVeeaA@9b2sLvueskdOi79Im{^&aMFXlIp zY#?(R8yRh9byIuwRF_iv+tOeif|9I0_+BNEbbEI~$T*3a^W@Ap$N5^Eq3A=_k zCny`Q8SK6`u<_c6db#|b>m7(=NXVfBB(w$%8JmrITsZqkecR5OpEcxJU7AVbK4&;t zxkvQc2)QjS&9(KXoq=12j0jYfkJ@wb_2%F=3ZRx8nK4N$s|b4HeT?kh9Rv(XYMUaNoMm7E`#y@iW#$ zr9sf1C%iNBiK*UZBXURRWsogu)2_0I2}1eA=I7d>Cug=McYNQl0s3=g#iXIuyn>aa zb{icToR1VVkZ;tg)J-8xMj2TKCB3$e4sWbPxfIt{07Cy_9P<5#)*bo|l?uM5lRn5y zxeY@G)LHF%@Z`vmcwn%!&C6!LU35uI`6a`sYzQsWXf}U;Vte87B?HNdIa?GvKmiHC z8y8(5w4Wmsu^o+DN9$U)ZgM*Ic!a%+rJw~bk818o6DkQRf-M$x6Dm{Skp#juf~dCP zox#?|Ubx>#2eGBb+{-V_I}?pb&m@`?Jh!dXZFaZ>y3p11Co zyV@aM=P_PCot&K5e$Hs6dDNwrFN$o4%p|>zQ|T0(?$t!A5T%}$=3YY`CAkipeVc$Y zfGJ4`z6D;l_{OY2-6oXpShtk?U56C=Ju4pwJ5}8|#%?a)DRpI?Uu8aE(b{hAz7o8` zp|5aNumeS}LRAPUB(dByHL*lK!NJJ#lL;q~l!V|_IYY5(?uv@JQDCZNQ0Ff5<$uwF z?j3TX%c2SDm+noFb9SMnH0o%KjhT+RPWQDrAIRb@BW*9SnJa32Q!7HW;iJRO9>l24 zn?inC>m55AyBU{+OB&v_fLE6aiZwJk;e#gs?}ZaUBYo2`ao*c^75rvz}&3h>f zg20~^@GQj@fxq9-orTziF0t%=(pO9EAdjI_xw8ydQ z)t#!hwlp+iozfZ(3=FNGo-(z4{5^Bp=4|)RspyAsiD-EQM#eYED+;O`7*^2{+oq0l z%SkQIwgByH@{+7vxltkPyH^|UlpdFsPxA6DyMzwRJU~7 z^n-ogLqJFd1_p9~C;-Pr>4FAD_jL|Gz!`R66>JF9x7pXGrrz`b>xVaP1Z(KGY_)S- zZKJv=wNg*6`qYj^^5&?hDDT|#)oJ8Si4Rxw%5Bp;_RG#aNlzXdU-Wvct_qztiae~A z2Oa`h;I&bkqC2u+=ldT6>N)H0cv$z;1f4)6CUBLz>ov?u4 z!7Siy!@-N7`-FvHhyY82hsQcZMWpA36nMS%dgSfy?(`tvqig->lyjyOS+!MPk7KG; zvFcZ8vz-M_>t(9(#--@ECd3@u&qBBDu|59smnxGpG{+gw%r8KqH|f~!?47eseE11w z95&XL;V{}!dw09WO=pddEPV7H&}OQ4j|FxqwoMTPaTex%%_1MKua4efejz1f@r1PR)BnLE`r-@c#JaeJ$WjW#R)u8|BLMk3_v zxVx>#&@`AvBpzD}QwBY3expovKIf?huqr74X^%mQHhPU&=0@i&a`oeUjt3aUNegGU zXDie>m?Z*~0KE{r3*U2iZ8b-mc@mr-q)T)^}q=^0_RFlzG3rInri}nf57)Ij;8HfpJt27x=c=fnS;EAz<2y)^ zp6|8CBSJ-arH7T~Y(*5$>``~ROlP+kM09+-v=Vc z>BHde(;3^VsTJQh(#@NJiNE{F!ZJ2CLXBZ3i#HPnhTa|t{vfx2$2S+1y8JQX1eek3 zfwn((%hq@$x2m4T2WMSwM{n2oNVNY5@rVAiF0=zys<>Du7FpFwZcT1b`QJ)i#^ubO z=N%CqF1>Oo!x29G$nmuRr z?N}H<*sg55F5ioenR+g@YMl5oj~2%}RgU83mHR1S|lG+LXAr z{Dk?fpSx}|lOl#Euz!-ZfO4A3Ps~XqKj|bG{Rp|ZQqO*ijgDqtuquJfe0WJU)kAAG zCU%4Np%cH%-W@{GmdD18#{gKPWefTX$jvR}C;C9<4WUW!jatge3?mL18cPQyTxeQa z+P9Qr4r@`0!-#6!XafVn>&z5Jrt8={+?SAsU38$7LQpYQs@CPI=hi zVU)`WQCGJK49a(x?UYF~g-PGaDE!?@OD`M;D#URG09AmHch@+q8g)<#!j*Vt!U>1B zpFB=@X8u?Y0SW)j+H8snP28(vxrCdn(aYMG_?f1F4H6{(*nKIvdr^(JG~8KM^Lu6& zh@li!3)O8z(J@=o3s?x?7tyxb2H%vu>o1tkK-{QSYL!4PmHOmAtdoDwE7l8Gj!NCB zzsb6HH>|#oLmD7=?!ya0|}J5_Tw$3dd2LU-3avI&;vmW9$CN6)4o(0pHRLe@E}m(sMh{`a8i;opq%&;Zdp0$9-|v=;5IH6sE5 z_ysfonjD8#D+q6Sk&$`(>|5J*7+2zoc?Vy1!7$3TLgtGCA=cc{!9z)ND6zb~eTzy< zx^91B&-&&U_9-0WQdw5!FYuPljmJ*0f`UENhW5M&T&o^%xpg_`s&V?@_;u=XU5O8X(X!0sPMAXCVX}Zu7qZ!CGa}FZ&HOw4!kAK4&I$pN2_Rr>`ixD<~R+*QGaQx_awx%Cg=+ks^#(|p; z&bHSHPg>NqH&0izccMVXA}j=D+74{SYkDadUJPgr8a=9^dd^nv+INlS7rMPQQWIX; zmCBNH*=Mo!21;s~Qml?Y0cz#ot5~B`4ipdy9?^{=eE=CIj@;ubjooslfV|Cz6uzx) zf50XpNP*Uy&s7>PM&OV}6FQED*6_!X3gKqYAy?Poh-*ew{^Q&5aJAlnl zJf)^kmO)etCOamMriK0uuL#%Zc6Cx=thkSIok{=eOdS|;wo<4??w(@B zj5FMK-vLHEV3_kDb|0LDdC>w5Z{ptDzoh(ZYLg^YxGJJ{vzBTRu_fw&hE!}+K&`pV z6pSTag>ZyWUbKJ&@s&uUW`R>;>%kzNh0!qjoJ+E4J+4e1y7P-E?I*mx%_BVpE#0Z* zJ-FIvuPu+{P*k6*s&9T6C?$}^ZX_jpl{heG9rqNKZ?wDI8lpK0=(<~zR*QmIl+%RM zC}S|=fXgqVN%PUanvcd=0l{VU10%1WeHcm?k+GC!&_J(8e4%#uJ=;}7+f9``!8nI z^t5eTSHFUd^;V2^RMK#089X@x7qsS_L(QHciWPxOOiK&SvOK4?PFDL+;BBwhuV&41 zj!Uop+thJ%I8BmxyY|LU3V(a;WY@By4y3ohK`d)l$RU`gPQh#yNZS8MLKJtkY(tH= z?1d>%W65w_WFZNTGv&2E60bWn4(Hp{XgAi-B3CIY>u1U~Iuq^7%hUAaOp^Ega?#_7 zPVJ%d%JM%;Vc}@m<08WY-ytpk$GB-6IscgRu=hmlk9P34cZ}@o+}RR1vgA1&fxCqB z)Gu>=G!|iqFW*yZw%e&)XLVBBwVV^1wRFdhZVLL%-Z-)2Xu4KbgtD~5u1xj4`Uh0? zEOXAGJvs^pPD2ll?iiiuf}=H}Gs;f95Ae<&p_f|jFC4Ud@mk5P@~;GwY1{Vai`lz5 zz%-gFx=l61cdbXi0hqp`$j}FUw2f&ml z_XZ)f?S{VxupLEJ;5yJ=zC)`CpyHr>Kgu(y7^q92c=(2%&J#i)8VjV`J%As_`bq8m zzyz?alZ`SzEzV}r=ZiBwroK?C(g7&@Um$gajD&nng$f=5baj^_r#B|{yL#6V?hoak z;dCCuedsjl0GtdPh7kYOUL^$kfQ`ohc%F+LJ36#{ zD&V<9zG7_qx;JjYz;d3J-CT1t1D#SRo|uNyH)Nfi4mAgD59EZ&q`&0(niT?+I@>iq z{T-b?%BR`S+mJjO96N&@6dH9LP0siL;Y+x77jF_R{YTP=Rp^)q>|B~~KU*_o9YMF3 z9f;!Dw?$KcXN6uR8#D;e`U8OvC5D5vH}j8rFb?im5kAZ4R#weXo0ZfGuE8_c8K;?; zyT+G)7@adm{U~DPGCBW6{q0sPv``8*P&u?7=Eb5Oc+ z`Eb_54BdN`FCIIDxO9BYR=qNXU+6rbby;U4kb>Eou6Lu1frMXX++8!wHftLLhCn+p zTPHw@mZL30dEjDjhIKn+{Kv-iz^qRGZp=Rl<4h|kV?+PP)Vsh#nf~wNa-O6SqNHKu zR5=!k#%UZwL?>J1lu~Jvs9BMQaY`CWs0|sZblP#)LM3NPTcgynsfcQlZAVGcVgJ`X z_VfM!yms4andf=#=f2$*+Ss)WC6Q92g&x-zXpRClFBdG#12e@K`4<+)9f zMIf3r{L@p(n@M%;MwXD|rjAz*buAg+WURj7XzM4_()NCnbkq>GMgFIKv(oDPk^^pc zZFMX&k-eQ%ER(BxO!IWcf00;2D1p}|doCkD`IJct84p4g5w{flxTpPnfxK7Az87$` zN99*Z^cAqK{Jwgh`BW_z5?B@US&qUFZ5L9{ zoM_S+cD_mVF#lJAO}|-i_O*UNpK6#hvbVqg+eZ{5lndNB1|E;v5Cv4k)I)!!PKc_T zoSalRIBzw`^Ele4(F4ZQ{yo}V&%sVwYC#te z$c}9^o){XC#2p+gv{S&6Qgq7E3D*%1_0GW^1PH-`QA60hd$)}|EdmOj=Ot>DV2K@w zSt}}?CpRD%-w@#UU#L{Kl>YlpjEX47eh<`G4FR7RCg;j61E1TdWtIb5s{EoQ7_FSl zA7p(?OUK8ElKOXKdC@CfOOKrO`iX60H{G~oh2a-EU(!oEx{?~2wc zP+?Rtm-x!3bbSgzEIWLnap4!LTj@j4+)_dLK_qEaP z+rHpN)v1`FabF@Q=#7oM6~RrSfTe^e{p$9{7s_wc?-~w=Dtv+-H@;z0rMwWpO2PU8v7rwEKa<;ttyN zMdxR+U~^#UXm#Ysd)+#QNo_xS@fnYUOOdZ_`=Avq9L4zg2?I9+aq0S&xvjFf>Dz9t z?B2MirUBYxiS$pPv&CS%fNUu1`yq73PW0-;pl#)kwK27QAu9qh!MUej9-vXo9{ivc z_CC%&dlEO<3L-*g|7hhfP#jT_J$>BnO=%C|d~5_wc_I1vRS%KPhYC08dY$!2YwIjO zn0CZ6M$sn&bI;?T(@4Stw~CQ!Fc`EXg$RtTgW=t`o!SMXlZyFQDnDbFF0k^&wu<~T z@K5l|&oiBIODbiN)j{f6`Ap|;)#x%t0x(*kT%%|2IBw4tjxlWW{YDT+WGcJjH(LcN zd}JhWwa)Y&2nq{d=!%4sb$}qp=*1Hfc!|zFJZdbjcX5vdw#{P(O(%L3eRA-BM#!62 zB$F1~e}BS*3P8%#l8}MOI>J!tMt(k#*ZFev6XT#1I;=gTeZ2=>ggsP>vy5V2utObE zjzU5DA0{{w6eZ4EKtputYm(^4{clWH{n>!2S%sR1{8zNh?6X7n@F>{7s3@e*hqdpW z&#I2@=@ zf}l?byZ6K|6HzWlx|*^I@Yi1?+OgczQq&2i`vHbi~ z-!aQ~!IT1|a4{KYBzxDu+{G+XZd_RDJh9!S6vUPZG4Du3uGJ>)Gmv*FrnCZWes&zh zygL~DP~6#wea0udb}UepTQMx*M(F(z=7u&Ba!Yc1H{q;1wLO^s2T2X=gpOlO>P011 zZn}6OW5g+s2DfBfgniz!QC$0>KK~?VVhsqe_pmBIgO@aq5uYZqJKyu;JQ%UzJRxE> zD*LZRc4=8fcFtrmqbi~TN&?&iDsuknY2{tmDI%)ffr@Ti76#L1lxVitNskJf(abo$b1_%n$-l;m;TF z3BMDBFf@0Q30K4P6d30Rlco@XgRW3)Tx##vTJt_Zp=9JMDAj72;a!6+pG_a)MF<)3 ztMFE{lZ70uEo9}MM1+thh!{tMD1OSF?~?4b)$kf3eXC)8>m(&WxqxJZn5Yey0)i7l ziEbfy<=++zCobs~jwLQZ~09L2~c{BIUNt{fi2B^#3Sw_#k`tjZUOZJaGG9m%{4}!JG&R{l?YG#$SI# zeDS^@4qlGmL8o{u>~(pDkrh)))zkoFNx#of`8zNx7u9twNERj5XMPp}4#KXn3PAop zgIa<~8du@v0d(HfH)N^zf#dafaExZb8fJaNz}n}G+0xW9{#(fexmJlISudmy5aETGPhJX)b9r_$C$8qDEv8L>U>RFf!-_IZIaQs9zGZ7+mc5?Fu zM`=ZTzV=v|S_Z<_4m8L!MK_5`0eMfc)ZXA_iL(%#(PBQz5^k~^?2Ta!lkZ66utpLP zx{6O@?^$&W`z7-)r37gxz-*QE-y%k@1=g(A`BDr6WtO&2UZ%bl?#AU}(95Ai<(5I@U3`61~Q?<7mIYz>J zWIP`o8^vItv`9h(jTdthdN&cutSlrxqau^CQ6_b3=cT=}cj-00!)?Nn z8^G=^dkkz#p*({GN7t)q#t^0|_{K+wDyW{W^4zNr~yIMV{2~d2DJaU$EZr; zCE%>+6|KE8^{SGCh-K++V{NuKxl-;tV~2=kxWKUGsC&Eril!OsX7>Nu7-Dr;rNl;M zN%qN%JcFi`WHuniIQHhn^I~{elB#42NP!l|y>L5{3*=Npi!hA!x^dV&?PzlEn4WmS zVGUyLfurP{Zg;+_ccg0xfFL}3!|2W3rL8YZ8~gY2=ZBt`T)nXeJrHi=eud`gm(?t@ z))Tz4+8>$DenJv1s|r#Sr-zhkUl&SCs|@8K3Rg8K z1omK8-sNGOzdvgsgkR`dnVd~$#+>#3D2($=b|x_e@rtW8YYdr$_>w61<(={h2jkp~ z)DB%s2>U6Uqb8efd?+W=&cc5qt1Bdid{|y*DRO=kC6_RD5kBw;H1*#RHD21KJ(jn- z0GSbrR5nlPj)s!1KwqzM{UUk7%W~nPuui@rUBDr{{E(R*59Wa1jg7Y}6kAa)HqJ72 z=9GM^4jE;r^Si*6DsOCy2eh0<5+#K!f7V9J7|Q?Yj%2Ixd-4zgqy-vY3Cxx|U%{no zuy!975GWwq4Sm zVT_5a_IyQt=tvMS1+t}jw^vPIiy0s+HSrybe?fvR?`SNEUzvnzCN6PvJ+j@!Vl2qm z&bt^^L;80;3o5J_0H@tI)WZ$y!-R<;BR^h!FusZ8tZ}enumT)bh28Uv^S2!>>$#DC z4_G3}5h`$L>~GXso%ro43j=W(63vu6`y~i6rsiyYy&e;_wpz@N-}Zm|(Xh2LXZ$dQAr^E0-8^Gfmc!5J2DP7!qk|l^gwdXE&l}B1d$ljA$@=2)_u)e z-OeJg(`TMZEADI*^}pwC)Xy8yXx;(-w(UHVEBR}1BjhdsB-QGuqyTRXd`b{~a&>TD zQ61*ifu{@#rysXa<vEcy!d6u^jopVIFSDWyl0moy0n^LQ8VxbCmo{~c9|8{09&bH_| ze_TAPknNQwt{n0f{*anjxYslHb;C|*X2Af8tVZLyyFR>fgQEfP?^uK({@6y7c0rsi z?ZK9zWKdbHt(B6=h3d|2JXEa^cMR~D7uf@_4AE}BBmYZkIn_p0)v`+mIn{au!|3%U zD^KuHeq>UVJf+X6`!!*Hihsg!VDTA_@)D5afigNspCb`n{7Erqy~<)xzU!ktJnQ|Z z`08g!SAkGzWY5tcm{wI-aR{MR_J)yI)GPi$O3pV43Cb!py+$3}3szWH2$;U*A^Y{B zj_=k|{(?xW?)N?c)B*J25jREaJsi5x&`<7<=d!PD$khhT#&^l=;O@fP_O099nkCHDFcj$B#j;1>rAIfcV2F(-~7e7Q2<_$PDh9La@ z|G}Ec;8ceP>^?58zE$m$>f*Wejt%7tWXlmp+u~|4?kyf$<>kMoSO@hW=(SJ_a&97IUKfmw&vd;-cbADNQQ4TJ1naCt2TgWPHe9oQR~^wNCtXI<|TJ=NHTQSM~mLQ6Kle$>4f!{2{Qj=katT%E_z9m!RF(!dAKvEom z853-2COV;i$!E?cld_)bQEXst+?>Jk$a;gb+E_aHu9sq*j)sTxs&=+;v%rP3>tTgO}+}rnt-*-T&i42gI1P_FRLw z2_2`Cg9K}m2u?(0rKVpnWEfgy5d^*0~Op@KW0GIN#8h{EcarE>Zkq)IM$EIpoc z4LTA7>5jbt896Q;XG_Y|v{>tPV*3jZyZE0g==-P>^Rueg$|YtTrkcv&Mu^nV5 z=e&b>O^A$1INAqlMXu1F^E@|5s&^c;SFQrJWX!I4EqN16C2w~Im3i|is+8n4E^~TA zb7XYdGSgD+GG;O@l-6C#oOV_DEKN@+kt2IULTZi6D1n+wVpw1EL%$#}lQrXYix8ox zc>XxdNRmGMp`|OH^mBDgl$GKYeN$7KrCgUcHjM1e8Hn)vRVBj9fC&X&hJTI~<^Hsl zEsGna*M%k}DuEUqwc5qK$~i~lKd^vFp|T-AFP@E!2|#5^*WieI;iaL(S>twTg0Iw) zOUcd}9d}+MX=#Ag7RX&TAVGbc&hA88x>*Zrh ztj$C60#s?Tr{$Cz%>7 z)e*gLyT}GYsG$~|Km3r_wC;nM)y%o%N`e>8o@F?+xqxtuI9h&$iBM-;E_Uef{^r^5UaT<5tr(fq z>R<)Z%rTjgotObLqFbM67Ff@X;YT;Uksf2ZI}e^w4i>%8**0yf^?=LHi>)zWt?w@x zN${*f5GOj5hI#`LHv7olxJ?T^ZwM20RLFu%sn#$rZ_;a`U$$_xo`2MHruQ~`sjZe7 zhdpz4>Z&B=NT0bx^L4o3p`5|2u+eA{?({ct?oZ0uY_P4=yF=(8`*@K!-|R)S>xwoH z-)USX91L!4EDMes4?r%A7bFkEzvX>a{`$LqS@5&TLdp?v4Og068KC^DkuGK#ZN8G8 zytAwO3eD;FbxIa#R4kNdDIc?J>_2C!B5dF&x27D>XI@s57H&8ZJe5rGx^!aCLpg%? z+DcN5-SfKiwb6b>XBNNP~SC5`osHc)!$s0yrKcbUITN znTEG~I^X@|Mohy0GX!kG*oXwHq7jT#|%1QE}!kw$5^a{ zw6xUM4UuJrlM-SUVcA{ipup&LR-fY!$y^M>q{FL8oT5|%$56)JkE-%oklayH=Kz`M z>5U~;K2FWyoz1;~4;6DGOIgcezywE&W?71%$Ot?FWX_E?re^#c+%E#qn0o<%E)DaJ-z5$w?mHVlyq#HPtamBFy{0AD1OT8dM zBL_s&0XO!NtVWkJ`o8j;!LX0fi_x5;>u98`&0om_G3*2({UT4`Q�O-@{1-!z?4H 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 b8Cer%5gPx=G^`B%>8@H*)gIITAOHUW;2kto literal 0 HcmV?d00001 diff --git a/slim/themes/default/panel.png b/slim/themes/default/panel.png new file mode 100644 index 0000000000000000000000000000000000000000..8eaeaf942ee6279577a1a86ceb6c6f9116e03dff GIT binary patch literal 15641 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 + +# Messages (e.g. shutdown) +msg_color #FFFFFF +msg_font Verdana:size=18:bold:dpi=75 +msg_x 50% +msg_y 40% +msg_shadow_color #702342 +msg_shadow_xoffset 1 +msg_shadow_yoffset 1 + +# valid values: stretch, tile +background_style stretch +background_color #11dd56 + +# Input controls +input_panel_x 50% +input_panel_y 45% +input_name_x 394 +input_name_y 142 +input_pass_x 394 +input_pass_y 178 +input_font Verdana:size=12:dpi=75 +input_color #000000 + +# Username / password request +username_font Verdana:size=18:dpi=75 +username_color #FFDFFF +username_x 270 +username_y 144 +password_x 270 +password_y 180 +username_shadow_color #704f42 +username_shadow_xoffset 1 +username_shadow_yoffset 1 + +username_msg Username: +password_msg Password: + +# Welcome message +welcome_font Verdana:size=28:bold:dpi=75 +welcome_color #F4D5C0 +welcome_x 50% +welcome_y 40 +welcome_msg Login to %host +welcome_shadow_xoffset 2 +welcome_shadow_yoffset 2 +welcome_shadow_color #338353 + +passwd_feedback_x 50% +passwd_feedback_y 80% diff --git a/slim/themes/original/CMakeLists.txt b/slim/themes/original/CMakeLists.txt new file mode 100644 index 0000000..6b2e009 --- /dev/null +++ b/slim/themes/original/CMakeLists.txt @@ -0,0 +1,5 @@ +set (THEMES "themes/original") + +install(FILES slim.theme DESTINATION ${PKGDATADIR}/${THEMES}) +install(FILES panel.png DESTINATION ${PKGDATADIR}/${THEMES}) +install(FILES background.jpg DESTINATION ${PKGDATADIR}/${THEMES}) diff --git a/slim/themes/original/COPYRIGHT.background b/slim/themes/original/COPYRIGHT.background new file mode 100644 index 0000000..6ddda8f --- /dev/null +++ b/slim/themes/original/COPYRIGHT.background @@ -0,0 +1,2 @@ +Text. 04 is copyright (c) 2005 by rafael nascimento +http://darkevil.deviantart.com diff --git a/slim/themes/original/COPYRIGHT.panel b/slim/themes/original/COPYRIGHT.panel new file mode 100644 index 0000000..0096f9d --- /dev/null +++ b/slim/themes/original/COPYRIGHT.panel @@ -0,0 +1,16 @@ + Lila SVG Icon and Theme Artwork + Copyright (C) 2004 Lila Community + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA \ No newline at end of file diff --git a/slim/themes/original/LICENSE.panel b/slim/themes/original/LICENSE.panel new file mode 100644 index 0000000..d60c31a --- /dev/null +++ b/slim/themes/original/LICENSE.panel @@ -0,0 +1,340 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Library General +Public License instead of this License. diff --git a/slim/themes/original/background.jpg b/slim/themes/original/background.jpg new file mode 100644 index 0000000000000000000000000000000000000000..bc9f71bcfaead1c813ddcb11ca2c7babeb5a4cc1 GIT binary patch literal 154967 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

+KN2Nj?qt6=Iqlg)Sepi0L5IdZfI9&8)g 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%0D6c3@j_qOXajd} zTy7)q9sX<8I`;VdugctMy4IS>OO3FTC`@zMbU&SO?p<|n;vreUBw+j2y-F?XMlM{k zWWhi)>_HHJ)ksCTqgyxFI}8R<5%jHR$$VVDkJ}xKtR0UMbK0!dIF&+p1jp8~n}ACKC(7RCKlmPT^%AxJBa zsr##MjM_Tg5z^Vz3s(iiZ!>I^gEBq+>*qc(;`g<`^#@EeT5sO}0CYPFgA*AheW$N# z_a|8(7Tl+p>OHYuem+UdW9a@z;&SnSA1m)S{{ZRQzo?W;Ws5R_B;cHLT+MCWL13D8 z7K!^;PxAZ@rjTlpt{tQjpiVKK=BvGY7TiRhmDcmu%AP#9>gevGSX2P8RSLV>NCSXR zG_Jx3i2(hc0Iq$FX4|&cVluj*9V1!736IWc^BRTm7zgSDsZ)%Gr2 zhH^%DkzCD1@Cb6jecOt=PpS`ZdayHr2bxRT-yci0S1esdwSLy?aV`FTFS@+{0PRMr zRiW@rUZ=wJkE&~S&f6#s;5a0F4lB2Cm$kF`vPmNV)Ei-JY6>uK;f0wp4D=N*ZE?;o z%X-}!>KX5?@-MamI*BBSCUQxxCZ!(D(n_!cEC|5&uYdb-;H{mP-D{L1_MExdNQC)E#ZnUCc$6-~`u`vy(s+(Zh{ z`eAC}C_67WhoXW?qyC4MnL+uH{HO|%o5afc#uRDFKsj3#O2R9Xzg@f%} z8@F2HZX?(U={#4f!^d7fFD!}~R0c7}S}cK%L>zR_da=}P+R;68MTBR%6aY`ZOxLS= zc&{8<+lUVXD}p+Ydap7QhLN<6hO}%11QJwrKb>{_8$oGD?;4CgN-6&Rt2W5%!^e4C zj<$yQ^5Wp#7zA~#3wbxs9R!YojUcj`b}GGN)z7_XcGC+!VYH6d1^_%6{{Wx9ytVYD zncFqZMbuJ(&Tifent;qKqYwsJy4Gg6M9GqS)?YDJ@;D%lxrAQ)s_o-<+jg5OrskRmYF_|1x9W9iCt_J=f z%vKu&A(clG6;J3k#hYIzi$DU|dSF$8CsqZKBgjB`y8ed$d}j`anHZ^oKxDl<6E4e?PJ%>;?4 zI3|uWN5v4Qo{>}5q=H6j0Tne<&(eSoY9=ao4x{m@pn^{oHCZ#oN4{$6Ed-2{QW$ZX zqC|{S1|6|MVKa(~UH;UpW`v126pVgoB+{RnE)<+`N@u-K6Q916=8K7wwt4rZA_Z0LE9X@JHpSxQv2T-Z=l=k${;G?2 zAkK0sg z)^mKQY5O2Z;-p_&r~wB&`_Vf+r`=^q`EaQ^UZ7QvD3D>~b_tVO$!r=c}vgj-Fz zWuqBWQw0>hs5Eylf))zw8d#JD(fyYLkk zRt&GHTZ8)is({hZpRHSF;8%m{Q-TS_O?32CONEZ+#9(%>9u#Q zF3`k|0AYh$bUN0#e`UxZ@dJwIUa;0#MX}~9m_{9c-D}a>_5$GaeBp!mM-d8 zTWzv2j1%oyFRP>Nb%Qm3h+o{EO|l0~z;W?OVbb-JX8X;~jBsjO7HczHBN8W?%i4Qb9x^*A+{d-2NEZcA)Zz%p{_wFm9 zA${ZCvg>q~^?H9Q>2)B6ON)j^956lWHji6*Z=D9d2B--~0v7uJ08sbty*?_)-fwP) zm_ZokqV3QK9edR*&Nw`rRdx<4r-f+b4W0A$4bq6P;F_IzzhS!W(mhn z*Y~Nlc`jNP5rYHUrADN+rAr_(NijfS#Qi%}M(Bv^9QB|)i~+_XqTZH5vifA2)1fH0 zHrx=P?vi^}TVad*aDBHP zyw@|tn&7^gRv|YZQ3DJIY3OM#olNb#t!Y5!Fn+aXfZMqGvw797d1>hc%*; zyZo{C!v6qNe@w=CsPKJBvFUBGbUa^o> zFkF&^hFJHB`b~3nx_}i9pdHCRjv?fbWw3%0{~48TE<0|7sYHNA4Y zFDW_xo|nV#quLjJJBotCkR$_-YJF3qJ+K&hl*-Ho5+=F!$CYhSb|F;=kUb^`5!$l& z-nA@w1Ujp!JC;F#gU@Q!<(zwY`1n44NhjLR7SdhOKkpVAbjAhidqFA>PDKk61&KlGE(DYBCo%a|`g?;@Hts5z^&CMHkUl?MtH-ag$B)Ix z@qId_s|#^AT3et;20gp~0I$EUo(HMBr8Xo2%s4)xIFJQ&be<1uS*TXHQ)qBb{KRoy zsjuifKS$*~{ee%R<8u;lSL^!by7A#G*V6L;0Mu{CjNvxC9+&nzMwdnXV!old*i4D{ zitp)7i)^;Ei){H$p{*ejIKcO=Ux@hQYV|i0O>C~5NOK;e^y$~`tUeX0)MQ1e8hxc>n0 z7=JdWU5CeUjZ*zUh|Bh>dX=>+j7>C&FT zW8yZ%mL6adKgD_B;`S|+7WJ&+<9U}G%-MHQiSur}dQ@~#90ArVz2O?IH;CTT-qPPo z!P!e(OGRz8^-23n@BV6B-kG}V6v;+LRkwQ8~j&3<=f6YjY0s{!8@0R9^Z|0?+by8K?HI;{8uBy zb>3E;i&m4ow~^dVCZg*@0IC^@uN~@i`@iMR?=Nf9RdVIVQV387sGI@XklkXyZi6zU zic7A@6;LR~SecA=rBr`OV{jRq@@nr-2QE2lewc2$iEUhqrbz?0dfBTG40>2~sPKTy zORuTGfC;s69?V^tfR@1o!LF{4Pj~o#cj2UjcjKtU6KkDz5tNoqUUbW>hvc77{3^2ii$dFGR&3p^R zwJCkBT)k~P!@A>b0RWRG0F24~Ob;iQj&gm!!oM#RwZYYpKsMP)Fk6lz+v%F7=h;KM zfgtm{93H>%S3Qz$Gpwi*No6B&$oUn5_0S!Kv4jMund(2aW>3@8%0_|$mRW}o@tGbTcJ9?cJFqav zal}@XwzifO636Wt2HRQX&JI5>x~;OE7?OMZ)zWd(>4J-hTY*tnij} zy4Ltt$Opgs{?(&Wmx(Q5A&3NmYRwjzZF=s2Nc)9Re^dVe$qQ(rfYIuoRc7~Dy(Z3) zl!my{NXoDItw9w42GXy$Sox^DH6p_8WDk;k{ei03`C53HXo5-VYc$1IubuL+2gNA| zX=25BfH^&?ZQ2SqKRvtD-n^H8qJX#iAi_o@A2qpTd)z3_m|5MpAc zJ}9B6;}J{*&^|=ef_^(uEie@#AmWs9MMOz6-jS)XP-rV8bRwjFbVPGRf!3M=JN{Jw zNuzM@QzNBK6Hst4Dkmg=dRAdU1-;EI=9IAH(zB1Jy%l7{8O19eqM{E1f<7jxh*El* zZ)v5D(LfQ_qL>M%QHn)0;fcjH4HXBDl?8zqG^Ei(M|*x*JkvWQ_aLpQTFrmL{SziY!jzd729XAep6s-l2!927!YtY;HOlR~tzLeQIEB zjKxY2!($(V+Jd|Z1o76LK`nvoU{v{jt~mTDZZs~{kfZUazRe7v?m|7{og8)G)hhW0 zYFLPs`i|5_fh6zC zut1Ns2L#oRbSI%FK|g6@@v7`yHvv}zcFkhoJXnl!;4>Te@y_pBtpZTc&2_L)ntx5)$fs?AQIDhqa_m?yBR zZ|cH>YSc_YAdGufBXA43R%|NnGNL@IfcNMoQbGKYe4@X)SB)`8SIK2xN3H*4S{s_pLVxicnzBTE9-b zdW;$^UDdt&j=ZAkloM^&>|as*%kSKDt2GxE+84Ok9R^AEsPRoUpIxRFZf;fwb-Rg% zw%^nbaa`RU#%)6QcZvT1`NWpDaA03frF$MEe`?CiwX;gEsJi-_>JcY>rH`SGBsu4!CROS9|z{1+iqY${PWRnA$F5M-`i5!XMqrA)0Mcd};-VFde79Bp5#c0sodsc$loygmOi5q&?Ij$(P zJ4{AI*8czwzNcX=u!E89{wf@#^&?R!s8i-M?sqo>g9;S?0585Kxpzvel(g1{0k-3z zABZv6ircAFSMr40D*LS|97j>!dsib>aM(aLx9={|wYq!H>UpKEz9}tMHTMRo*5$Kw zJHZ>^w_-aH{{S_E!L(YPFYOXtR^MeWvu#nIxYmsUHnro;AHyVryPCK5dsS%oows|a zU(MR!oUsIe-%vjBT)B4ic_f>Y>F9iAh248x#t|0>ffEpUYm;I09@4m(|A?GsJE}S8s&nZk|2~lK19=Muj_4UE*)C>kb+ug8NeT3 z!{)lWUld>ae#@4{$JrYlWPDc%$BmX(((`{UoOw*Y>GS*X+M9MR!ooRVSOX9~ zoP2v$4K;_;>cBSI7t@2DymjgMSJpfuUuxZ-B&xVv69h-Jbgl>OrgFS=Rb!oEMK$MpZ?zWx3arjF(Z&VeAk)%uCd~m9kn`bWyZ9m zz}z83_V3Ml`L#-~rC z(n1|Z>z0@et#E;xj6anZ`Dc?<>eV&&+s@zWSoMj6{H^tg{{Wh&TV?eci+ZJRFoy=? z6e{-&VKKsvfOGfHTTO1>u|IfnRT+IidVOE7rE2op`PTIz~Xv}_1bIea`{`V zt+*bLJ}LED9X6>5-|A8z^9Q|g=i;2FPod)c&R#xW=jr5{&BJk9(qruog0<=Nmo-<# zyL<(fp4Dx|7Vq7&w2v<*+zwCc-nu$#3u{Pq2>x4i>QB7(u6%fEd3>L7m&31E(l*B+ zw$r$g%+-49)~-uif+;n2*5uu|VN}W6*w;T!o@L>>{0*CzYDkIy09BjII!-(#zax29 zwHMOewP!FOdv`sny=z2l=)#u%Apo>z>T92>;8F5 zR*H=D!9TC>S?9vKczpbMT(6&h)L#&~z7%v87^&1LS8kg+{Bd6@@r@PjJ(Aj+enT+@ z6qsYU3CBU~e*s^hwLTD*?0LGeZsXwWaUc+J&%JzO{;Q??-YItduzaKe6dVJIob<0h zl3Cq-PsZmjQQ>uW9Fw$d1eop4L{~S;V|kSUxpqlt1Fz+Pe(LDz9ggAY!TU$I&2v`! zCY7C6%K)oq`HYz7oK|>EcJgw@U1`*A@&@~8Gqfxac>0RMT|*u0r~rnZ1pI$$?d!FN zQEJ_%(|XxL+9Z*WVtNkTS0l!JA6KKd`^&Q4u+i%f8A;$Wa;FD89`)$qKC8jY$#+<_ zy3a6qc6SB-XX@UogSr6Vgjw`z!*EXro@=Av+D|=>^qClL zgS}q1n@~lqxEVbKbgf%U7R9t+qnvfFcbnJ4@#MeJtv;Vm=(Yhf>OIXvTzjOTMPLj~ zRdm@8zi1?kgTbm+^Aie@?6rrZ<0nfsDdhsgFgjH}ZscoaeMG>ThutT4rKciltx5E& zZQK_G&UxuX<>^i9L>MT_KMKameBz3wf#Vg>R>t9R!t{}v&8od|8dVE)$*VoNTBUSX z6w5GFCnJ+rTXjVik``i19!)L1MfPo%0Z!A!E0W{YkhH^jlo~RH~bKCv$bDq_cWnH8(t=ZKQ$Ja~}QatdR3`w1N5m0GiB097jE? zN0!#~s0$KVrGTuN+AcokBnY2+sf4K=g$%yu@23|30E8K)J9nt*Ci;HK2k)ueed;+i z5f$_wp466}hM*kKMFMCUPHE{CdsFnE&ZeLfQUylfIv={AxZ-FS{8eu7V>3Zx+|^Cq zrU@-Q=}vpm^rbB%fkihJ1oZ1rAeovvnx+Hy(Ll-OfI3tQ(9{JqKoL~bfgDo|7>ZwtCMTb|iKhg26vX`1AfBI%NS@}0 zXJ+;_Q#L9{C#=*ELEzD1wwgku^D$Nsd((GtL#rj#Bhnq^Y7;Z=H2XQ8NSHxMI_YFU}x&p|+wgD2Xcfw(aT7&TDpK(Oj2 zW~yD*+!=$?IHoci9MZJRjyj5jTFvGHK!+TPn-@w>;ki#DYN0&*Xws za7m;fnHi}7fhG^UQw*694+f(8FCS`svqH;f0*6t{R11^BpSq%HhzccgW+Jp%wru|Z z74pP_0qO5byKS!Lg50PghH}|rN$FLKR~CKcj1YUA(s`-&SVv=2J;?NiIp&oKWA?H- z8Z3*hfJBUrva!8^~01Ya^Y>WdGGJz~7-yBs_ ztA(F)&ssdwxXecaIjYx|C7@jFDhd~!fW+&(cH8NA)lB6giX}mrK;#-(MT-AUD z0ahk6R9s7n>d5dq_o$on*QuS8KT66Mc{BJ{g>N$11dwV9!eB?zgt)nqz)@)&h|JX& zQIwT`QjyI`=`uRZRI>(@+;>McQYo-cm<$pox7pf7QP$ytNF3&_d%+Ax%`vMb zT-I9c^5Cv>nX5l?xJDgkpR{U=H*Re&yn@m|?N4s?hA(an#52pf}l50GZd@X5*&vmkeMJ*>JhyrMR2V+XmaNoX+#^P{I3(#5!TL18}?M~P{y>g z-;~5{0Goy*r$5``D;-p3RlCfk6cp6L?>~D_OEZETLl9-G|5+_Z8_tw(x%(_ zV3E5g`J{@x*)3{SmAg)3to{_PnVqWCUl%w0fBfn_bzZ+~D<72~`f z$kX`OnqO!RS8)f>WRX8n@tXP}2ycelum?LpBw~Bli_+R_o;PpKx#W|4hT7szagN{O zx%2vT@$6O$8Ld=-LQ)H;Ee0A~aN_(c8nrynOfc-b8SJiXB5&rW8!T5V@you~>g?#X%$BZ!=73>@ZdJt3 zwtrczH#Ax+`fGYIXj?1kw%v^Vl5@%HUUyfoOM0Vwb;}|Q+gRF25GU@c?D*Byyc5h@ zgO+47xE=<0tbC)>{{W)$-ZSBSc8k~FMXfenUg5Ub-HhWt{Wy+k_4>5cEuHGZ;s_X> z+2GA;y{pjpny|PSc}4}>Uu-Y1KWKi1a6f1*H-u_Mqp04Bf&9Rc_KXgCS3X-kI()eK zB;(3wI8Pm2G_B7pT)Lx`ByAb$IqBb;^7omU?po3nWtkwiujqI+*T1f}eF#rbMuug` z=@pjdog9a@7t9BMKI-FpeZRxM4;0n*k!)!dOa}`m83(p2D|wetfU>AVk4z(<=_mE~ zRNeDh(GE#qF~cq>Gdk7O2AqTwbV3iAb0E1PaOMKh5exY(@$h;R_I?f1Y5LD_Z$E}q?pMxzp}c0 zPOJ@HrNyyv0;-_&1O_~`_u^RArLQ&dakF1S@eN72;9}|&Mhr0P0YLy0_g56zzi(Nk zd#)}6abiY5-5+;cRo1lntG3eHt1!01%v5dJ;sG!{BboebMcqD~wW_x+TqN93fgVN- zLF|2|x=QE9PCZ9v=A<>WV0HmB(kr9j9yUS?8m33H{{Z1!3})E>0N8aN{{Vk_;`oJ) zInlkZDT9%;OC7++x7}Q()ad*)Gp&s^>(V^6cPz^h&Tu*Uk?&rK%Pu)`@Nx2SeP+jr zX)S4y!wbqmWqwr8Z*D4`Mz-dmp?P3Ef7A4@n`r+4XmvV^O<;Le(70%T&mEc#U~A^WGP`u)|v-jS;b(-9RATZ>gZ+gJjuIa70cVcD(Mig=Ns=On_ zbY|eOX30xsNd%3go`XF->g`)P>TKS&*2uKrlqe4JOhkS0`ZX_Y{C+nvMxRr3U1G1b z5P#%mfW65z-SAya%jzBf0EcBHqY;~fxE%*+u48E~+1CF6^6j9oq_w+11GY&r(aU}V zq}4jDUa@wrlJ&Js*_D$F31G{BMPzSy$k>Y~&>v~-+t<3AWn2wW5oin*H?DE#EC>KmeiaTd5WK*Z!sW>DG9y+ji0H>4nJ( z%?{*pPu9N2Lg^JyneA*oLzjE>DaZYU3J!b=XxQ) zI2>e;_4id*t=zbqw8XNEKpUr_k-;4O=4*#<#a`vavdFG*zGOk;Ju9zgT(<3tPC}>x zJjB2}V1w{#*<*#{F~a?#@Vzy=Csn2<%ZA!)Or&=NoE&jpcy3$(K^5(F+HvA~a)R}{ zZEXFq1u@a1^RG9l(rR?~JgrrOZGe#`cMjvYuKq52GPrV?>0Xk;z124eCvY9BwQEW* z-1Lpia!mB^SUf*TcJ`!Ow77}g91iv9^tM+|WZOpEXYF^VD(m3ky01>Qty=PekaH}0 znp=n?aZ?;mf7DizFa^NEI3#AXY6~VDf-#d=*Q#fxd&J3ATv2Pw4Y|5|)n(MN{{S@y zm;{gQMC413K|4f2=qNJCLm3?V)G&f6L%_u=6;|>HReAP3DtyKqJbfmT=>BDi9Eqy8 z_CGaojLN*;xJK66!?6_w?U9=)iK>hHMNaGh4>Vkq>c~JvP(6|k~{{U4t8k13K*>776bRFvR zB}|T-MOXj=DOpSsI~v8h={kPB0xD;@s00p81%NoOrLW8;J?H@RG`q>`N?)02soJg# z20GG~JW>YjM&nl#3`sQ`yMs$4;&DO7DApyIcBLkADj54z6ZE2C7?U$UeMp{$f=5bF zz+;MvZL{rCee+0Pv85!Qv`)@lRPjN1;%Pd~0Emd72{X+p&S+w}lTp2M27*8{P1hoj zJfH7DY-H6=%unG)?wN|HoMSX@J*dAGh2T$0jl}i*X$i(+jo9XfELI(9rl}7cMKZAX z%@^XZobgat0oJ1j`Go~T41-0)2T{k zkW_+5KT2ziPpc9$Re6A<%@#^_%E-X>q*mL4C){yWdF+q4A7~?*hPuZpqbG=_HSw(> z$GG>Yw{WN+%PHhcevM@e>`KalI#ihg58c{{@o0EcGD@BgfA>}xbpV*a{HZh{Z#yGS z-LvtUQ1k3yepPi5a4=#Fi2Q0ovB5YT%{XxCSAsYumgW>&+@R;I#}zavxS@8h1Fb8o zFv0YZkxLT91D}jkZeVcoM?TdxrNp9<%*WkAvXLQusV)PyOvfj^DmWm>iK8jH`H?j0 zMYwh{$02$F+|a=-TMpnC=nv;vS;H}4C8kW(Uv2vGe|dZoG5HFlxd;M|d8gF_cIdpH zWq^b9>q^QdA}VVoi5ViKFSdQEAO$c_#V~7l69$cHL#*vMG{u1aSnO(|5@ep03vh4& ziVMTY} zVBnB>if!S53?TG9>IyL6gYVL#SiZ~8rmU5MDEsN}1yqhF-fE)9 z1OwWtHv?Ra!*b#~P{rraNC)d#E*97E*BxbYR zbI_X57+gtMAl773#1Jvm(^61~ZVArO&MCHo_Dq~X+b@E)_a7ogUwHFky4eMQ@s z4~6)PDr(|wTm#d6M^HQWUX{{Ev2FhVcUA$`0mld2bR?g^)^8BeTGv_fu1b|)*4=Q{ z*l$RlfG9fc~gl2M=ds1D78Y>el3xam=NE}r+0Y=$bqTX7)nKH%Vd)oyE{Zt|Uk zhlL+zqV1%(iRD|_n3?Ce{3f#8+iAA0IW3tA0U+i&MLIu}s#Wn5h(AMDS3cp%xo+VK z{{X>LJ6jq3b*~lRGphZeuplM0zbxQ=uTjN&C6*hBP!!KRR|~-GUA^L)w5q#pKI^b# zD9;hzxp_Oxck$%o%U;IbnJ#MXc}6_dE4z>mdi(Nz1y!LDV1X{I%uYz0?FT#v5l&lR zHp&pHXK5!M_^P!R7%H<8?YDVgyH$+j0nlfTYTn*yu9fXamYbZe(l`eltCg<3Xxdd) zDBKTl}cFWxcOUd+u>_^tPzqK0uMyk?UyXx{+%K$lt zQ|gKKkUq7ySE)-$blG#gntZZmdqiTq&+Qhqu4*mV1t3}eAp`9+oR4k?d{nUI!*9y_ zPljt2-mA;F0QGE;Wn;I}ySiIB0Xwb|s2YlD7@NXCLjita*2?OcA^YY4I^L0uV$;U#G=w{{XUSbkAbur&6pf zft|62z$e~iwEp#| zMPY4T4?b(BDT#d$T; zb>{v&y*QpVeb--h1m-?_aai9{{{Xq&OJqq>v(D4;Rrs(Mb@yOymodru&{zv3GO`Gg z7+`&WT`R?ISEg{u9NS(d{vCehr&Fj~evnQaj`6|#Kec*q3caOWI$yX03(Y9O%b4gE zcpV7&uRC{5XIpiXRCX@aC6Gf2>JNAk+c~Yi6*>!7EuBJM)9(zD8A-$z1|be0!63)9 z*5@v@pD!6_Uf!F;b^idpHqwF@0QSsd>s;+dp-~}T6dlAI$TjEgHSY*?x2eCo!!=CX zE)YvuxCG09BpBq35uQPPl;*0_HLzkb@WW^knXp#(&*sjo#h-d?l6jT`%nw?O7ke{oRehz8@LxMiNu53gI$jhO+)IA zncckY#Y&Jkz~_pmRbt6uw)*bEDmSJ;5DfA7*J;lVd}gtDexTSTO|f!Jmddx@I#%sQ zs?Vg@FvVmo!OutpbHL6kn9Jl`^@5J40Q1wQYVP=Fho!-1Tc|1kA`_7#IsX83<(}Mr zJAN^5glL-By{x#b1=#ZY<1_fyyJ7Wrj+Xt4dW%o$JHL?s08){a{JK`F)-GSQXJOjx z+ldAWgZ>3;v3pUZv@D}7)F*K)GJWJ$F7BVh^qoF~PvOXxwCdL0B5KDCz4s`D04K0>KJyyx0z+~e_#+J?Nh0^X27 zFb)8o)r#x0$Znq1cBOwde>NBONctReLY2jdl;kr(X(r{@)^%2sB=q>@2Dby%wg zYO(@c>j#R_rnbxj5sBlyOG(|uwk_|1+;ko5L0QQ)NRgPR^AB3*?bBrGaezlm(z^hs zoQkEKkp$zKt?w?<6v^#OXO}nZBZD;sh%rzapp4hket9IG^a_DZ$21ZuVxVp6Y6}jL zK;w!>FlL~+0~K2_Cz^qY&oqUP6$F}zs%m7OzlB6+pSq$)dV<1aMG*PmiZKS0ag0SF zat=)qX?({@O~!LbOq^8aWQr~VLE@C+hcTSyt7aLRYRGWZz+h&oR_zpdv5BKtwV-fn z3Hz$AFwX*`a~@)txUjMBODB=n@u-kbG4!eF%>WsjtzBs)WSq@ZIp`|OY{Eb|G)w(1 zg&iqmz@?nY6xc=cP$xFs3P@rb4GDbmuf#ZLcN(oYU?mOk<#mt?+jM zHkyX6P#7Oq1_6xKcLOQ)fIr0+*s1iuo(%%zuv>;u@=Xz|!qki8?g!KLEiC>K%uHwa8)G1h8GmNCsrmbd~mZjVXrRql_cPil)Q33gEgZU=8Y zD&e31K%F+()HPZuOS!))xuq=7#G?JBi$6o};ZJAXkC``c*dWv1kqW zRm3 zgks$F=qdq|(@t!Ib;@plq<>CZ$KH4}4W`rN3-XUbKYw%~*q| zqi0-a@vdyLGO-yoShWX_dfe855_#!Wx~RumvAKG4^$BudU=B#;p$Xdtao>~gTApVF z05MeDT$n5E9V#_7Qz#E0w-N;m+!ZB95;|0cX(B1DS|mY{Cjyo_dO}<#NCqm+W{Tdw zP37HZMg%fC7-V6?4#uLzl3QY<49BYglhZY|EjWj3w$V(0TRWI^teis^VBzeJu9rqkR-ZB_fO zp+JJ85@d1h@g3_D{{WU&?#~{{?QpxSvKHmfHPDh7TtSZEh{59r6=U36$PKt_cQbA$ z>ofU$@k41xl+R;O)}ZBXi4F33`{uBezM7W1xGkqrNLH0+nB%|t=C^;hE;-8V7AIj6 zgd-6k{b_YKH$fmt!6TZrkCyIXO0+P62C`h#+bYFvndoOfO6OjlJ>6jO1hjQV=^=Vqp#su*U<3X_Qk1dx`3K{R*l_DN%GZa981PPu0QQAka&NHSzFC-Hn-e+jSNiY z6m;S%*m!P|#)nSA>;Cb6CgsP}0Y5>Q;stq++SFhBs{ZDr7O<;2TN|4M^5=?{IHkW`Aw~i+tg>me7fkxSQ1uM_0e1(taJy`blt$q^1_loawM5_Zlk@||9ZdlLd zaq363w|6ig;C(8MP0vvs1oWycUO;gHMgRgUCc9I(gh`Ww2k);%uMZy`*1z5XFp@pS zCb~KuR-J9SIA&lD$UOJ?73OSUNiy6SJg@l`vdz-BRItd&slRP<@odLh`w?^0%p?LD zIUdzEbvsD}0za${DD5=*kH^PfE7SZ*|V( zh{(iOJ;4WiHV@XXv2g4>`9mJ;dPP1?cZccKyQf>5uD$6b00$d>I-ji;^p{iyX!6(s zOns9dhx?|na&4P7t*y(dNk<&J3>luHwA>`v-mXve0g*jxcOGt5&Wmo^*=gSH>afI& zPq*P#yM|?$<0rLKU?5=3(>MVBbeijylmNE?FNKr#i0xXQn9F%MTKkARV)SAh!6ep~ z)+Ngv1c#B;+`^-orIg&W6&3L7;>MB9Tb2Z_-^4EL9SsiW4eQNA*7AAi2 z(rZqJ)xA~KwEnOlu;2&-GCO~I$Ok7sk9CeQKkI}DD z`$=Q>oej%mi#F~sjl8Q47=76tvD&;}iR(3XZ6=q+EgOnoYHH$0KJEPf09?gRUYCb+ zT;JLjj|OBn8PME9kRa{czzOy-*w=*@tlreW@o%x-N2#GkWBXUJ@f)_6Pj1caLh3Ev zy}j1im4z|@Z1uJY8z-Ha*2(t{IUA$ zT3*W=uc_1BHdR~DtY%3E5gZIpxvhFNC3o1{d3>$L?B)kZ?~3WahH1QwLpPgn+qOME zT7XMI9b`xL_NAvP@EW10yL$cq06N-;ZSLNH*y9~$yxpsJE*-6PRLPv=fz#%@{{Xb^ zcA~iq>|k>Wqc|Na6`eF#T}9NDATq3Bz0b9JxLlg!WwoPCpnoUK*EZr3ZCgKTBR?tt zt=dbieB4AE$RBI}0AGLCYF`LT{voTkWh|}ZaleWjL<4|FY*#|oi8QZz)}0F*a^7bJ zplMf-F2*+qQSJm z_id9M2XcPDjc4R?n8B-J7~7d+ShdK?Bu4c6P4DGRAH(<*^sywz*M2g?aRMM@aH(KdpT#{s-r>zp@JgM{px;^-*7Tk>R zGl4(_NgD_w97Q$HNp(p=7vi#cHx}S3!yQjg^IK*R&(fz{bgs6Bm2RwBUpIVZ^D!MN z%9qx%yFv8e9`yy?dJ272v0;@(#dateikSjL#P|}JR`4SJkELRZUF(5;}R=aGB));bx^3b?-l9N zv+_PNCvEUDZD$>78r{Yjbs6Zjq!7d0RP6_mSot-KCr$wBerX=w)yNgmbp&9+_Np%1 z1u|;RN${HeY9geNIU=guPI^%!^Iui@wVQ-uqjC170yGz#g^wSV8++1|97P(C(n$3mzMzqlKaDAA zq$G|77Zz?Ki5(~}krh_vspQAC7ZY)(k}9%(CZ)K|EcT&>869YW9sXz&6);9jQBgR@ z<3RbvNCfm1EFkkWG%jZp-I?|HIsixad_ymm8PK%l3$IVFq#O9Q-IK@QbVxVvUJc^ke z=`l4U@~E1YAc&)Aq#{Y4C}O~lnWH+EK`;QGxuh%FC*GK`EhegYBZ?7u7KO0KEI@#2 zmzgDg4OQxHN%pH$f;~V;>qVIrmLgTLQpy1WGDLuAU^hby^!KD<>~o4P>gF3ll=^r#utU4U=iqUMb1cv+TGfpYgkg_@N zM62Yts5A-9456|k<|?#&#t5r`z>btesS9j_3_5}N)p-pn(mGR>+{6H2;+TP90+H+g z0QqR9Qr6Uf0dxNV@c#h1&cf#IN6lEI0wj-`W-7u#6V{q1PB);k<_gJN_vmSgZ9967 zl%oPc&)-*W7ea<0FyQz0r0t!m#tcu;ny6f51OYWSZMNgM#2kZFt6UPR8TX@6be3J) zR;#(@{jahIYJ+Oxozsq_8o68rhayj2CZcXL1~dL?(fU9D)ZMnbrAQy+y;pI8^q?c( zy;iqdtu*Q1>yM>STx}qqr8b=U4Y}hQ<+!T6X;C85YRy#=<9jLYwbagzzsI3an324aV z^`vWrXSGyVNy*0)P9v{1gk9%Ah9J@DW!yV)RFQxVDtAKQMk`UN1;theI2BAo5ISQN z=5TO6Y74>lsauH%ssjK??N6l)*Pt%pnWZcUAm$9uYMXaOl`SQ*J@y}Z&8_A1zspzD z6}C|Vku#7z`OQV71I@blxo!PQB4?&>2fwvuwDtx2mhSm?ca59SNJ4u4IjdRjHv9fq zw|>Ue^BuhmMDhUUJNs0%uZ@i_c~KVmORPn;R=Q#prZ-13)9Evs&8V`Ph|=8hSrw$+ z!7BitNh1gG`cfnQ>8U7ozn5e)w$r)bL;>xA*kIIa@7#L^`n9LCCu0Md%zXZhM@};p z+Scv3`W;E~?yAkD1d)5(PA9nduC1NLY}vl>AV%5VxWO5pxc9Dais?N4ExkK2A<;sW zShyKSApZbYSnMjF3fAhaT)Cvyy4uxRQU&KAd4vA|QJnj9p3za#&6^|9TPST^lH@BO zYr8>Xo};Mu!Kc<*TWp&^HlP69tC`Qi%tkAjYg=$CmNxB@K_o9uvIjp(y3VfV`;IRn zqkrX`hwYBM`*TJJ>5;YT@tsH z*H%>~ao1_>gNnY!%Z+7jTV^T>teD%6=N{hq{Ax>Ep1U3^;dgve=7(z)OKwfW_DK;K zJlNWVA5n3?YV4{NBF@N`dx zcmDt!_N>>`x!x@2s~j3s;~+4t*yTcDURq zthXVU01rDs6Ca&%{9|8pNHq2|=r8JTO0AAI_G#!od)6!2RQ#svtc~j*9a+U zFk`9gqG`1HB(|?}Q{`RNIo)#Y+d;P<=>wo00IPg8EZVaAhQ0g6>+o*gA|#H0bO7|C z?cgpDtV!?9W7lrHxo`Nz7aI4TrrT;2rU^|V0#DSyuOs_%1zG`(ooLg*#^*qqntquiF!EPvWS)Wt)5K0HVg4NiumS@2Sf5k<-IJ z&uaySb@2An+Iy}UfOOH@7OjQo3pP*B%~1C)F#X*XJOGD80z!&OokT`Tqc)`LDnD{By@D*L1f6+uMXP zZQEnz+wN{L`(`>--?P4N@9a+do@U~WcMKK*miCj5xc8{HV$ig=F0o5V1x3WzvlxWQ zB=r2L^cVciPo8c*n@J8_H`~16;Csvi_jaclysQ!qTlHMFMW%J~fcsx(?7w0O!0di1i`Q;>#Wo_pX^A~+r^;)W3pve=DRFLt zv6P9#cdLV6L_{iCNyAQ0wQ`!vf<1PN0}v-4+P8RKtyDFes`!y7maJY|TII*BbgcgJ zY?KNQU>h;|iq&K=I~d_akr|$uu5G)PtX>x_sSHTun&^3g>;@Y^$cmE34p8Z3&CS5# zMjO9hrE0c;PUN`EvdW=(KU$*I!l}7-?upOgPWQaaPVWGNh{auwT(-AcX53hq08YW* z+O4!mxB}c&BzmA%GTRVDJDg@m1lF53OcJH}3NZi^-`kq5SBs{^0d99T>6Pv{&N|ON z)y3Cc)Qx?s_wB17z$Q=oS7U}uNu2@&7UIXwJ$*j zYgqxnj1ou58SRSY8-%Z>LX*=5}&%eibuUTuvC&MnP63~ew zvVk1^N8MgF(p|l8%Rmm%>LkFfjf=ihfd$I|BZ8AarCc5<6*~?dXEUULX@=1*2t1Ayc6;|*Q4=3 z*Zd@D^rYEFy2k3TZ{fwUw6IWM0L)2H>ZZz!C^xAKpm9M?ejbLfx*q9HyZf7*5`ps%uRDxGwP*s%9;BsnpH+;*60{q|Ix7 z{VHvsFw8O2-nBW@yd`C^rjJ{KM?v1LxJfX6=&eKulh5TyA&ept2P}A}&wa1){+W@E z=^#v1zEZ#19`wwHN2Gn!4Z*XVQr%|os%|S<$n^=Pw{cl}Qxe3P`{@m|VKD}yIJA+? zRdB+6DNVLe0=YARG>*4OKBbR}CcjylfB@@I#Kh8loN(nva zxUrd|6s4GoK-`EFrHvQjmSf(Kx45Xd z=~eDE6Go&tX75oZXB4?7{8W%c#X%soC?|0_sVyC+=8ea&&%HE5Oh}~xh78oZ5TyQ9 zSD0ooKQvsc*NO`cM%ekP4ae$4dsIm$5kuoz1NMrN(s2`1i3TU|rT|RP!yAk_+I}b( zTd4dhG4!L3DlS6;-OVuF)@egP=|OWnD(GW9Nu`iDBk!dwVD_jd9VwyrP*_d{S2+Iw zbp?-a#-Ou#=x8k2%vF1iNFRkxdzvCi&mh!wm=t52Qf~JAX`zWdXbeFkr^P1!0R2Jw z)Ng4x9@IsIa6C_d=c{13kiIr=#ZJ5s)ibuJ~8*4w>Ai?K3pcv^NT4KfF z$1b2AefX-28CXn`2gM;RFi!`iYGQAsk_F!1*Z%7xED3@rLvBzB1`k>ZKx7hR zRdI<>38`5pXG2j|Daei~nL(1PJ^iYtCIJZ%`kI?;;NXBNr)NkR5${%cfi7$rk@r*^ zWTyLI7~~4GYTAauxJC!`{QJ=s?iLYDskp-fu>Sxxp81h8CXtRObjg|TNMzvg6eLQL z2;h9x_Sp#rb6JFpi2LfxPyIq^rR|`VQOMi##aDO|11T^n71X)TDdd3#Km!v-eHmEZ zO|Dcpz-jyqC?!tT^q#dUQct93tySiWwuvB}f#@78^+FX&&OLt1%d2 z1}iF)+9{;S>qW)r>Ly5o?^&+^jWQq{R+3doCfGfP6&FBrD!WH+^dik2!onDI=Bzfv z6_~_kr~z#%yIhcX09DJVwo)EfrBuJs3O2)S2r6<|;;Zt*He4%=$9l8P8%WsYdJrfU z_c>`pk$pQeA z-1n+2GHGoWbsOgq%@#u;(+kB7fLJsMxN>TBcXZ_9$=o?R$(rXgmbt%^GEFtt+;>Fd zCZlpS8=7SU_$7|xo!u#g?JB7!PDmm?-D0+5ClE|W6w(5SA&HsqQr5AhA5QK{*<~O7 z>6ws#0+j&qHH-2B1z(= zTPtjCVj?lO=jm9k(kK#cGc~tmRV@M)M{mE{wdiKfqS!18y`teVHfMw1AC+X*F%5F@ z0nt(yZb4r0`srG9WWJaX<(ogmaV(&Lj^tKdGp37{L#hQOkuC1J!~Xy+_XMyke+b|V zMk_KPFKF;d4d9?#+Q?wZ#zL5i%5ydNciPGwI zb_3bHV%>vj0T->=ESCYmiTgds=s~NFq}s3p+h18E%0UCTjw_R)*I&7+{o3rQLcrWU zlw~>G0X&JTF6!-BogSnwoV$Vo#E?J+J;xdMsT=rzlH28l(u|DkMEM}f?dZ$>$4Rb@ zjYDcKgw#u>;`@R1U`QV09eP)l)N0&o6^j1=5lAW~V4TOrcXYSMoVTqsSp>5NY$?er z9f%S;QNCPycdfmxC6RjIRYJ0%ctCoe@m>qTweG*P)Nb)Vp!7ubXDgl>n~RAY^p_w?p20Rwr)uP8~)S7qqUe zY+F|zl+NX4_{8M@0J?O&X8CfaE&=O8LEG?0BbvKf$}Xu}4{XWWLrOQ-HObYKxeah! zwD!p()e=OXrD~iztqph)>gS*zulTPk`%bqn_@dg{+YX!o1_JZJk(uk(y&+=yh`0^A zjq2OPgCqzX5A=rD#bxkKB3i!1ov%Ie ze8*vvB$7Zsi9FW5LGnVKFjjSyPcZsZ+%lxtSd_VA!n@|SjxqTh(vdY<0l6m0$ zka67eCaCbMlj36S<8J1u19@eC@!0|(DC$QNXBSFJH6k)=bkj$?!G z`PW7T#Z?%P0g;-j<-2D}H0Ic4%!Age=6Lzu9J*q5WC#^WU?XuD`|B%Q4R}Pvl0B)l zHrm4kF2xD-xBmd!^ZC^iEMRTV6(!fv;b$qa)4jY~wRGGYfg51Sty(`2M?^8Pq6lN} z-nkd9l2lA%;(As4_SqrAmve?4eg|O`);V$Ow`#@UB1rU^02!ZZbh;VkNdR;+n)BAp z!sMe789BvVy1UlfEFe;H$i?IOdNFkRRFD_@nzG)zPR=b_VYqsX8uL2Mee1{v3o(Hc zS+v(mTvlDmbHS{ z;Z1fmH)FNdAi)9qa5xWqz|33hIVU>TZfZn`!vt;-s;0q$KPE-^VK4q!*+T&)^@c6%Zm9Dg+rtB0jcN5g}ipAprhM{i;Ynpqf_;0pE zM+dQy_?l#5-rh%FXIZ2>HCkJs2?AHra%VhOKli((#6lqL*0=cW`?hTh>u{>-=)_O4!=MXA;qL@bNT6SYA1CxcyI-Yn>}<4vJHWysrd^gt2N zcbMk0?dZ9fylQR!@pP*e3iimlKrG4|`HW{6pT4r&)H0vpGh4Plp~}@awIP%v5DE1* z1d7dgl3+BiNaCKNUZJ(xn~uaFDzTpb08><70FoTtNXP+a9Xisp22FsE{fVWxj0Ej1 z*vBHKIsCCvx-f|-fX;a)k-!%jWGI+YM-=Wr0hjLWR9+pDf>E)-uei)ITG zB>w=qrJNiNJ?fi`0azZMxXld%B2FeIYO}K!5_SMcGnz~470Lz<0U$62558$Z1w4l6a&W%Q7e zq|dPx0RpT60OmdD+$IFn%>Mv-ourhE2{`Cv?k(2(ac^NpGshkYvk(?fen0!|i2b{+l zpbSX->WL)vk8@5qrYl7Doy)oF)oTv#hA_U;|p_PO2AoU#8z+AkhL|mW$ z09*b3bwF}hg99-Fi!>D`=H>f^F}LUtarsgktvQ&hY+WQo0!WPYqWU6kQ|Tlhnucyk zX&p@D)%TSEEo|;c{A(*fGZ~^p#~nJ&NdOoOC07&+r7Fd8m9cG4WYc9uu$68B>sFxWhEB^rZ z3X2yS=qgCZB=Hq(#~XI3z~|nK`l{`J6-dAXsWmNYV}Mve$few>Hh}>9^Hp77Zy?-u zff?zVG}~{y+C9;aF%?$$*DXs+acaS#&f;!O`gwmpo!CAYS zTdQs0r~rK8sx!G+WP&cG z4ovqGMWeLIS@x{b$k}$}l0XAJ>ZZB?%n^)x*1>UhlEr=V5m>d- zR(rP+!@FN3i=L(Wk>R4ji zZnkzbagMM@&2;q|yLx+I5Dq5;GuC@oH&v(_glkNYk@iL+b2y`~9?z;Na@Ny*nN)7y zumTT9&j;GFYX!Yq6}xenu*lKs2e>^y)l=s+v*q4x;vp_{_&)ytoiJkJ11nE)`Bt&k zCq=G7;v-3^HpZ-pwqVPzSoiKLrEcP_?1$~Hmv z_swb0-??hrjcMDc0uka7gn=Wmtk&~g5v9Lo`&$idu9*x&jl>QhPCs8((P}hy{8Le8 z&X(BK+qS-OBi3a90L4)IE~4Ai5-uDq!H~nTAL5%$r?z#@`fIjz9w~KvvlpSRC<6p^ zfzNmqFHGO<(bf2sy)W+Q7VfI^gKbA?s(sGtn^^8; zfI<5z0bFu(Q>7Mk2->)}tJPfuf9AnT72pxLXE82#8zr5;h&a2H^jj8g$V#@_f z0ULlYIGF2-&N<(gt}Pbtwxav$F6?V-1#K*CP;vkgWWe^FwPn3^+t-z$E_wD|630bgOJ$ zHeYe2mT&&{rEP^@TJAW(KOHNV;rrq+zZL)ca$AZveK*`KaYGLPUR?=B@y64sz zh6vz$b?;d`b42%6(iK}a(Ets)U}jE6JM-4L-ci@Z$NaluyQ_U&@u#tOQF`w1EVahi z0gqM25J~UYNbOvY7w~P~EpdE4{hRk$LBA{(2$+G)emS3N>)yMjHVC#B)qt^f>yK5? zImy5u9iq8*<591@x6DfiPM(trNZo=-;C^+>o!O69j#+h^OJ($o4brzRHdo5IxOEap zHAsS`LcrW+WX~11#G2)iC=?>wAZ<_riRt&(FHdwGFnf?A)$`K4_p18d4p-uXb7?2> z_V=dJ_+|TV`^~_XtdSt@93H2&K(z1cG76j%T}^y{*<56>v@`c+uNueYbF(qf4sF^Q z3+h4M=z(NZEl{` zjlN)J<^YmSa;|ud`;WR50l<&%Sl3V;cL!A}V3Xc>q_9aqApL6>mGtA!%g-GXt<>BA zN`iPBL<-wuP?qgQ%gE2cfn0D(l0jS!y(oL=P!KcmT9uwYZc*ME%|DRC%;FdidUN7> zM73_=VR4%P1>pSG15K#`$OHLLN<(mzjiHDbnv<1IUVc_PmtC&0b|sjc5PuUjUDa?M zyw*wSF<5MC&8q=Q1^{*ITJ7rW-m?eNc8pBHtGnst+sCCoQCOCMGw)M&>e{eZm6`XV z<-xj0R-U7@RYt|PxUAE)PX~@98rOKut9(=jdqhI2>Cko@9zL^Nv9E6rOPkqU3Xe4y z5~^qIW80YGMQ-s2I;}06W=bOYY!pMO-66#C1jKee)gBk%_ikzm_=MZPY!7Cos!^M2Q@8Nvb+u46u&(GqDoo_Q8cD zfUC(d0(q{J^y|m`Cr&1&@ZQLb&22q9Lt+LdDOLX zuuNo#=}&U#MIt#lHC3C7=9OlNl|I9zF`ZV*8Wi&#DlMbRpe2dKbgK`>5ftYLR;wlkTfLcJvYDXs_^r~-dKfl@kg<1jIkBm7VXc`@@wFraZxfl19x zOJpl743p1ONg3zoHKou+R8VtC=$wiacloF`$vKnOtlJQ0tz4-ICzId3OIO=E%Q52^ zt4IY%B*aZvQ~?yXKFP*wHnV4M(dUpSnwXAagOQ4mEAPKBf`3y>?@u1|rGTlTBBTz+ zl(%W6W{yo477_@9+N)v*LrJ(#v884)&T1^;mTs{El(>i@4Iu!Yd82P|D9|tT`qJQ- z6!-%%P(Wf0G$~m;ky0^}pQS-iGr0TF#Z3(&Abxcceb3gQ9P>fvJ^N8KIqic`ryLp# zd>TMa1(@fhLwA!k027(!rW$$?K^vxkO+nj}JXEU==kBJaokl17Q*qL1B#a7zPxTrd ztS#KqmhDN;T7!xqr#)&WDM_Mw#T47BV-SBTTzgPXC>t52ZaC{l){&bZXwbxy8H%do z2+269Vtbmcnr0b@_U4gH2?YK0FbBC5OtzZcwqkb0Si@uE?RBcHk{Wu` zz$9X5xR61C_toicA&);amKGX!WK`ePZQW^RNSWy(s|~giEE@z(pTS#xtTQsbFjC3 zV4jXXoohZMM>Q^g8far|7R~e~eg6Q(IXh6Lz7HmOs#o3#6<~yKUq#m^w zEkG`^R$@P=+Lq7^CpB%R2+fVah#>Gq7`-zDVj?D^%iyo;=CnE~Z!t+J7@mi*rDaxG z$UW(cs;&UOt;P=>s6^aMncG&f0~?6X6HKVN*ucThdJ0%tg9<71i)`)Eh? zK5EDR0BUO&+RJbg+K+y}l|tOLwEDz!%^q#PFa1qH-XdzI!2pvZwN-C*qvn|%z3Hvr1}0~v3^5Ii zk)HIWL1`qDIGVV=lD`1iGogl8bvU|4kse53?%xFOjN6FBh2@T zm68v*#Y=61Mt&+{ZGfgR&0&NxpDq=kh&ZJ3_W(fSf$vgEdZ3jwrSev0YWq7r=C%nL zF_GS&+*VBdpK7k*5;eI2h>_n(M`CvrZyMYE4^PWc}XoB)ktuou{Fw-mCz?G!IB(FvpWMiyion zINMdS8A2!!f0&-LSoK=Z{zEO*^4SjbV+4HF*Djr;{nbzbi~tOuvPKE(S&rOh68p{D zUT2qdl3HZI?0xyHmq9FUP6YBYPqk>gE^b#-xG5oo4^;N7sHI(zu5y2v@z%8+XQgqt z8)Qkuf-0MuTPrwaC;3%~{`I=wm3kV|?3^$?55Ib<=}>mZSduVm>#rI#nrmqciVG3? z`K`9qZe7X?sNeY&mjoL};)an-Ipfg)lBpsxVkyhz-R+MjIt|S2_ zBvxt5Y{si*Wxmu2$G|x!pTNiJ8vaiG$eH8jHF` zv}`(?Hl`JA0Ra0!9eMmKJLL4PjZ({cXL5(Hvqd;3LkyjNatUu*0^z+9%F5;hW^13P zKy>zqIV&VhHnQQmL2z5pL{fNkHkAnleIh$oE>Z2_Y~t3dj2RtGY}V((t^i3MSkDnz z5pYJ(K;+hqTQB{(<^el9d{mAeUSBB}qeYbxaHI06ncE_g+1#Qhfip~408SuPdDS|U z2Wc_S#a8z=sMx|!^=2vAlyFR(Vya6DZXC|;cUEm_J1uG$hxMTl+l1uOojNf6*=>(6 z3It&LRktnqR%Y0RnU1vKn@-oP-9}wQDiJaYtW3|iKXq8end#*GM#5?JFK*kGv{%B{1ado9KesM?v0E{4Ii^H7pR+{m5D=b%D$8pG z6EnAgQf3zyex5Jty(3+LuMi1kV6fyieppI}8TdoJWrduq@aV;|&CD0RX zTOmp0!5sVNrDD0LHy{={=~^_7>zRN$^%RxAjzT4eU~L<%=UE|=@#AU4e2%rm{jPIz z`k*!(Sp|=m+>jbDGT^mbg10>f(OU+ZxRy>pVTkaOTdY)MZMs13vp^ zx5wJg?dPxRl?y8|Eymf+HLLqwODbGkN|Uq!^U(hQimvvP%eOKlEVgF?vs=7Fsvw*} z&H?W=+DUyg^8LCxeK6K)SS`zlu_w%3;;OXi_Jj@n7a&#s6K$I9+r_rq zRREPRKK`|wC+_9#`awcR%vNpNg>-k3r?f!99eUL_3Y%r14rAVt^$Km<3Jdy2UMo1b z?pa;7ftVDr&sAP?xF-U0RXG!po|QMG#K`*6Tp+N6Jt-2OQvP5|#zCF0?t9Wc8bJpY zcANmMxDu@Zo`BVQs~ZmMa6!)B@mEiMDY!tmhd4beMZK`fK~dA*vjz36u;yz)AZ_9# zN#><*)#$<}ndw&BNHZYy6G9*v=RTPqjY)#=NGy2ATFy5w?P4<#0w_>-84=nlt`9R( zr0(Xki`DeCq6he>=Z~!x@7%P-kbp=kNfXF}`P709rDDoM5+EFikMsCcYHDq$EO2RlM{#7AE9nxS7 zP(dftfGLYYp79ljPCkm(#7vX(Roy_?1mm?mvv33EkG9iP?-~)n$c2VnrdVjYyWb2T%#5ZOo(sYDfgh8RDUV924t^HD(3K#bHA-ilUi0w^SqGf-K3(v~Ko zJJE3^%)pwB&owccj8I40DoaR;9hI0z+N#-)0R3s3;;P;Q1(7|cGztme znWr!i$1^igh!VeWsT@x$HOb=w8hw&DzARZYcv(PwBTX-(Eq&#U8#f&%fD{HaJ$ z$u$({`&MRH_smlwhTKSub)-dw+<2$9<=Cm}AX7yxhdt@f}q=C=hQ5eZI)JP^E zpL%R^CpB4Zrg*8{kOy2;Rg=bMrHFwBVyadydJ4E(fjfl$R7z!lHwiyVLdTiG?NX2~ zL4Nt7=FkZj1yU?m-4Zh$I@7M%7-{*e$#MvZ5n4RNA_1aP*kwk{#6brj(R?TZ^|@C;<|+n7h= zOxGsgmJlNI3q1SLYen0DrMoudCi$MNoYgK(tIxH!87JbB-N+(I!TYM!Z9BjJ0Ek@k z9Vw}pTUm3-o@DXC0)=N-pvbC%q!QwJK0HUzX{`6I(1?Q>1h-8*s;Z ztZb4GOz}!t4W}RhwSk!8v;Qs)cYj|?ziic*H7^p2R?@H`^xdgzf#mG5| zVA!nGv@08A}SDjb>q3FRy$;4=}{m_!4WlEi`|j8 z6LnNEB=gjsF-Xi=*@z-eK^YZ6W4L7q{{Yl}6=7gz0T62yXGS*wP+$sHxgr6oZn^=? z3Q29yAol54uKW#sS->=1y53%Gh9{3! zCa7$v^DT+@sShU$*R59LW}q|LwwD4j0Wbs#i)YH+<&Eyk5Da75YK3e z`B)U4hc_Gk+lFJ0+B0@aYEyetYVR4F+9S3UMX6CrY6VqdZyD5{)h}w6l-iA1lp3L0 zqpj-i&HE4JoSdAT^L(D?zOSpi?U#K>&?5Z@3cqkYln7$+=|_6~<2B1NLP$Ad)qTMK z05E%Z@zE;JzI2B0xU3lV{4Z^fYu0k5!b`1+;T6kD&Zap7t8M7FxqJz=e-b)>@h_lbH!Q2kD5(FMAD*$SJ%4By|Rt#B)%&@-K|iL>YV zvITux=TZvc!LA2)R1kx^&TBPG89hbC`taK0IN! zG+t_+R+1%xg))fpyN1b^tlvTBQ_V^Iz!c+*o%TnMh>s!nQS+{$;{vCyZ@UksxYM7z z3o=?FH8lN=ee%78Ywe0@o55uE0Zs+RA&mD7ou_-Ig^VJ}0Y+I@js4R%wWRZ7Y8iq} zjBih5*c&3?r7x9=Pm`!@Q-b(0uf-Ok-ijv~k6XsMyitGtGzuqDtWi&=4Yq{72>B9E z0?)Z89p}xJ`vGeooJ3x*&|_j{o%o5BMgL*mQ2Xr!s|^+-9hNDysB+Bq`ihd) z;p;@m$CCu}GppwP@ZLwAg853VHe=q6icuf0O`AwQ>x%k-w$EJ?>@zPa>WexL=;GoX z0)BhnTfJcE4DE^F{uDlxAt>(Dl4$%!X)nz2tYXo9Ad-e0xP95Iw#694*e5O4ZI%-I z>;Lipo8u+!i5e%L?VXg}G>AOdLrZH&_xvasVzQYroL)w|wNX9e#*J}75kVkCzKO6y z&ALL`!la(Rjn31qr-+1Yift5nFnv&4F?_F~(f;qe$qMs9?C&wGX=cszi!&2eQF%hu zPUu{5em%Nd?|}VogE4~7tHbr_E?=7O;jTP<$(JftM&0(#i6M)+<#KB&mPb_x>s23? zE6EZb3x^uN?3xS{3yQJF4V8v$&Q?tdKD*2l!6){%3{E?*ZAy8KZCU>ha1cnsf*{G@ zGg1-RzWmtwJJ0Zmrs1Oz?Bc(R(x`s(=IGB7U-N`_0Gjmc%o7u~F1yo*IS#_T6|z;2 z3>r;g*V(M^K^7g84|eza@VWE_5uM-m#2|ReL+_yp@(M7GrbI`hPgmr7$DYW8=g>ba zmZxWBIy-U<>JGjN?vNjtVEQB5Xu@QT5LwpV?%MHS+sB`W`xkLr%I||e1J<;a-07;_ z7gEVXZu-vVTc4ztJ;;=W2>5d4%6S*JYaTJ3M2#A3756D(?Umi>`tE<$ zF#3+E{l$7SAQis&`lP4XtyQU21HRWVPm{s6&>Cj%p*`wVzsvR2Sy3GGbc50s#Yc06 zX>JDqQGEJ_FI4(`y2h;bzFIQREx31vtbZ1qs245**8pK@A zBU>|)BpJZa80TG0r{CDe8yLpdoq0qJQ27YBWX%2@YC9Loz#-V6o9&XZcWy;pKn{n< zJiANm7*fho8XDic>ym`7F+8eHu{7}sryF9o$%+glWY~-z{J^e0ebbO8EI(@!??Amx zeH0|mAtd0B!sI1YF~r*kJH@$&@eM?$63noIU{*WPsWUExsM+P3lWbsSrlLBeAVUz% zIJbCq*FwzUt3cH?D?UTso&xZA%s~CA!}`kp2?>RWE=33etiRQ&^Xa_R=qHQV!v z<(Ks^jh(`>$0$FM`n!97?MV7GY)<7B1y}cT9&9Llt1H+{CM!S&)~oJWD}-7nK{dvK z2&)f(QJV>9`ui6ZUR8PVUTCe#IA!m8c9Ak>WNA_p{XmGcaYKNJ5D|juEJB%pCMlS# z=tW&511jQe@~JO?Xs*~2fNeTis$K38Q~UyjNV4|V0ev0sd97D~m>MIlDtX&v6PGUX zGApy>;iipq9q6N~8mK9YcfDTm&TFFA@{(lM(_o-sgLzEHb7sjm>CgsvW1T2Q1XEgd ze{-9_`c*_+{YRTJ#6X0=lVvecjhQ9&Dx@V7tP){XS1G=k7mFMkq+%m)zRkbl%jU52 zx%exJkB2Ab1u&`EEiSCxqpHsU$6%zPB}Ht^cF5+e2%~)H6f%z_nRhACvlx)DxJ;}- zT0^I^I#NLKOP*J)pxihY#M?c62k_I!HQxF^49`LA8e?|8dbu5Q$matrbtYvx)vaTW zGntg|%#B=vS%W1^u`+x^&q>_I zSp?aq#?E_3@4}T&)i{GU)$DYGiyXk2ynYYVrZ5X?DK{qL=8ybsRuq!&wD)S@tfMx{ zPQ9kb%|4a1cdP{%e0!#5wbrVgI_5Y{Y|=qdN%q@|k5|j{Wa1!yDA!_o;WNA`;3&++ z=YC5{m0IObWbAzdTx=5A^HgYz7qKAvumr?aYuZzxg#9Ut(}^m(Ku_x#$^W*iniWJ# zdMBrDHuaJSOXx=LV+84t+4|yZ!003KA4lKmXdRr$2JJ}fCnv@@>4-Q}If^@x4DtkX zL7|&@SJI9EKOe2}d`D7}WKA(69!tThiB6mQ?4=tP%aey}VU=dUvW%S$byNUVy?N3j z={cG+ofSTf;q!uc>hugFGlGAaU{ql z0Jj>IYXwgnvwhg1C9M59Hu+CTu<0Q{M6eWwt)SlRT;$0t23dgl#b5SNmw0Jn*xxBT zq`U^Y1bT%F)cs2na)j|n^`#C30IB{P7oB&xyA{jh&ZTFt;G(DuDFf)p{#yJRDZQao zxZdr&G~52cz~~}hFvyw(D;X*&<3eEkj~y5P`~^??zAIxayFtY{9f&{%oDx8_xH$hZ z*?5yMCb>PbeVm)$v2Ov>6V{ zM$s?Rm5z%qex0nBS202thycR$(LEAJg?HYY;9O&Xv10p`6hW7H)IQ=PlCZIJ2euTU z&|UVPC0rH+2_h>{IHJw2^Vp*;k{t9*8@DmpmZ41;b1V%3PV;N;LrY)M(g2d4ad&^L zLv(`Zo)uqU#&T?K)CYf-G0*-%Z*G&iZ@p7nT6x;p8FOS!M4zLuxDdYA(~Ey6|DyW@ zw+e_T3Sf2{`A(nOpgC5F0(&X9`t!pL ziq(yyrzM0lhvV)r?ujpWK=VG7P$YDhbo=S@%_;6sP$YG;yhXNTt%4ehOee2&Bd9~6&4WPf2pBL=>eDSA8Mx*H0PS9Pd=QEj9gTd{jc#>ik=ftk2 zuVHR2JqfklLIl%W%OA_`Dq%VFQeLFoo zjg5I7O|v2YE|NZMd0nEhBU-l%6)=>O&+v?~%k9yf?*o6f$U2@m^Wz4ji8f_1aPs() z#x5WFKeqWmLLk*?bn03kNXV6Lv$~fvGl?r)ydbRQOe&g%GCoQKZzUUg=hV7A< zaMcXVUtP11_TE79eKqbe1}rHvF+~(r{yythvnRR2Uz=7s8pWWbZl7WKRPCfbK*js~ zz-DwiU$vf(;hcSG(Y5vi%6MyEQd3!y(gGlcE)Q%kb@En?pk!>Yj>sw3k_f57rls!& zZ(lz`jwnlp0Gpjnu~`v9zmtxg-j(KmX<1duLR}!>1}r54N8KS8DF!#Ta&MEJs?tFj z2-h*A0i8*zE+fEy*jHp4yv0MPh)!m95HLf8*ZRqgT9dG$ERxGn8?Fad4)e6H=~G2G zH9qsDW!p3UCT_xjdVqh(%adw=T|b1E1F_(yYre3R7evsddTxlc>Ov z%F6}EeALX=!J83gaYmU_3Qpj=0}rMxK|fTQsH+M<#KY7O@u~ao<>9{q8(Lx|EQ6fo z8LJ7E6}`ElBy3F2u5d_Boz`9^mhYQhUX@>AYl>>U|6WMl41a9R)Q#5O36xmeK3*7f zFqu)KO_~30w@-&(2smvkh-Ak%AuonHwck z>}wSYRo8_}&&pf>C;V(5_5I5GiCM*>SsRl_gswWY`+tC-ZoKweeIa1+`x4 z99iQV2yEtwp7M*$ja76#FhytwWc;pQEuEGcOGz*>QrU5}|D%WVESK``-Svzm$_fN!ZqLGu;NnF1%SklnbV%b!D zwI`z!s{(u4aK)l%e5tk!Y~Tih>Gc>lbPjT?;Q?F|p*9NVT<~bJJUTsu$#Vg#ip8Lv z5-*R6PM>X~Mshk#PtiCWslsEl8@e_$m__%{9TgolcU8AxOua6?xzxva(No%pp$Y55KE6 zM8P`AX!v9mXap?8c$suWsi9M^=-vC89ZUBosU&9)v>0FRMI*63464%6cg{F*nA{>NQk@4Tk` z{6H~k;VZnbeLq2jY_pgmsvK^pGUncm{EAzkRY7-Iy%Zw;Z)}3po6iTFrbU_9c0o4I z_Wsg4B6p2(vf!Z{L+7`L8vx=+z1$HLUopK;R?&tNjrhC3zhq0=5)Zo|atB|@7(0zi zNFz8i%8WD_p;AycZ71uD@|r;B?ch$voGynVrBsBlVJphz^-**0jGy=4Wj8&5V5f#z zdI5X>O|h)&apbYof$$Hp9L56(Wynbf+%5X64>?!ra;eFXg_{3nN5Y_MXn3O`o}%N* za=w)aVfuU1o|JIs_Bd#r^<%mBOYEip!o#er~?5xi1w_QWYXDOmp2ddeY=Avdf-O z(3L8yRhvmzZla+h?QGlT{zR=bb9x$xxQzhH(AlWpQ{Y`H zWJ%#h@8{6lm*%aY_)3;%yb#n=HFtwKiOA`22^O`FD(vY?bKMUGNl##^shi!0&flLT zSTA6_7ss^6^+P5Q!*lDt5BdjtRKle9(sODIwEi?4JGr#Krr}ej7Q&Z8p421!#!>g3 zMHbOu3-#PlZp@5Zg&R&y?}xBq=M^TXGRjtQ{Gve9g6vs;l=kxbI{=a?zGq{Q@S5$l zUW|&M_MiB8D--74M?wCnXO0-geFa~o4bd=Sxd)`SWN`M!#JDt!@%8#xFVDYYN z559a5K;##&*Y;DAD3!^m3<>4Qv(7~<_hH_|L-7fau>sHAhOe`>PQvmP27sA=?DKKn zl|1S>mYGgcST$22oO(u2tKYWfi$vMU7SqG=^72$!@;^QP^-(QiG5yp-MP#U5^;T`I zC0!z+<4vTOJQ3iyOzeZH8Do{+uJCkE5RdB3aUs%cPAe}6b+@2+h`RYRXLp(N_tQdd`wZQ={n`N;J8_vM*jXb@kvhD`(5ZW(EePEs)3QRHOu=GsEI&gk)egWY&Pa3=BGZqajm%%m_pyoJ0)3HDmK-W6D9u06fZx%rO94$l`S$41 za?lbd6oN0X`opELD4vZKpVuvRr*-$d8WWu&PFqBdDzm{yCeG(Tol;P8R7TZpcI6Ab zJH@KQ#V64GZR!kW2bUBeVuel7Cr!Y)=`E`Y&a{>P69J-P6E4rrMQFsm8Yj2GCtenF z*-%0C`Y1*4FSC`2*}L+4>0wUa46o{YjgK#@NSSw=(7onExpu{==lHzx1v)M9=+J;7 zYhvxz&Sn)5!=?u?$N;PpI?C^zi1pM7GZl+?(S^nx%ZQ6ffWCUu|TSMfpe_laK6<;_D zz`C}IBcUu$h%>pmJW*GZ3uW>sfRh1bbI2$SLWgX~E5mX|mBMRTh=pO;L zolLSCi}KEQlzjXCKpgHU4t^JjaWAZz;vy13JxH8*FVH1vGc#j)dGT{Zy;Hj(pyC25 zWeY06SILy^=cxixv}&r}UhEF)yE>Xxh+T}v)|u@R>#8axm%E$3D)F2L0oF~7Gs6;^L^<9yzk2jh#g0qD$}8%YDgMGoz2 z8$M^EFn5(@NVO&77OKg)9;DegndKRss#^!QUStUU#2zApvcP%Xo0u3O0@tC!UQ!>a zU{iktZ%U*XbpPdZwoI*`cCu2lPm!hB{PjR|kBqH;-q%I4eE-V0l+`>H^lL%Ae5hky zgbMHClFL;FMdB-KP+a_6j}wrI4xrLkY;g~35^T7+&8S(yi_IU3Y{R>W2Mnk=CYwZu zM)j(WQ`@>fx_I^>J+ueLG!)9trx;1#0C->N!5pt-)1KM1fn~x*`bqV408b&#RTg6# zNe16ke>auI?v@g1ls!y*$-94TyOw*qakvkA7IDiju>dcFljPi=PG-h2eZ6mF=OW;^ zs2;DzzR-0s5mnaT_K~{9Q<~z6AdU^;XGJwLL*(Thb9SLohmh%tcIs4C&B3FA*RCKI zqcSE{%zZ_y(ki*1DmH5v|Lm2aySQ?5jHCD!C>om^&Y?;Q<+~Du?@i}!Fxy?f@im|ptEZpSHR2ce3!NSUJyju|ps!1o^&M(;4kQG`5t*cNQFw<9w* z%fV9bgTnGM<=k6)6=TBT&mSEsT||9^GKr>9OLS`pXZJZ}KiqieTinWht2@n0JN{=a zi5AitvFl&|mDlwty#{^A5$#TR=*Ot&*6`AZdeZv0Eu$kHL>KLS*F0K+#H@bz z*v_3?mOF0bx57I@B7M2RIvJ>esO#4*6`q7i)*pek^EA;1-NJbfi}i?y`W1dyn=*~$ z(T7;sbovDlcCo6f6XW9R;Ufpc-nKz6f-u3kvO`&v=>pmJ-iIeq zcN?F!nN?eU9sqtB-EX+eHo819u+AQu_-bkciC#R*-2i3g*G1SXpMF#3QP#N<)Dmwy zK#ffzNVN+fU0(vuK7+T7MwhG0FECatYq8S-V%zt-{7rGauPN1xhMKuc-*kn!k&}(S zd336Z%?-Ia12sKu@?+`T*ZGpbg6S2zqs-KDX9B)daqRAZ7|q5ASfxbU}P_A#&A5SwCS9W z9LnZ87}D(2j=5O?u<<5gJ7_%(F&TS44*qTd&pw}}kO|y74T0nV0rQ5f1)2cGoxj>u z3%_<#fPDI;8ly>VmuF|J&bt$iuZwP?-+GM=e|cFK*zLoy7RX=b60J@LP`V?x_qHIHj@Bw)ftO#Hh3|>Qx2_TZn-RG-oIZ6zNk| zwxeeEYT*p{e(i_;0Pav%+@b8^7ZzVy&xE&&1iY$9>2~>~4j6tl?=xwfV?Rc7@$-&L=syUUML;`*+E3J<2X6 znnbw8U`O3XX>QPRkmzZiWqZ7PEPnY4I6Gg$)|xL*%=}sgXTT4FsD1Co?qJAg;$arQ z_b%(*s%MJF#dykN%s2&`Z9eg4)TtL|qaG+6hxF)nW^7w)*7N(&NUhqwx~J?azxudA zyQvio5SFzVV%u+sUcb1>B2M#6>V8Qhi8zZrl}m?>L??2|@I)xJ?sAHKgyJ77)VB$jrD%eAm&|`# zV|A5f7E6n%CAq5`_Z~M*xOxxjO(r>8&d?SGYGlP!*Ea2<>TjBQm3z#h(4YShOT>=J z@^(c92!poJbD&^en{dPfwu)cBF-#dBf3#ITKLTG!0MN)U zr}y=RgQDwHg;D9!8!E?VR*n-7(hL=>hUAfDIZMQ)8W(?YO^LBQvWPB{Uc7QYr*nV1 zj1&rG4YP^RIiaUWzWQA+XvtM=WfoO0=~GdNO`x>o6K{_h&K=KckxFGZ_EvowKkpjZ zIIrdh)hm{v!f{ee;M*pKnvEP?AO)j1Zx`XO-*_W~yi&pD;;v%qwck;9$aR>{b*yB3 zqA*I@h|XnBP%-uB>;x7mQ9a7B*_)DD0eN zk8GljgycHY5=ia&z46JR0&_4fj5TlvYzW?O^cxqJ-9$r-)VCLco9|iuAd#J7OIf9) z0r4{uV{ng+)#^1t7yB5|NkX5$oCjox`5q1bg}f_XmqR|s4_bco+~es;DgXxj0|{o= zW1es6%Nz3a5`+%mh<(1<16_!ZG^MGJCEEuxFAFig^pOdoWrc{@UEk5B6s}f`W0l9Z z^bW0asjz3?Hy+yl$F_e`wxbXE@VT+ziJ?U&3t4e!L({_gYpZZ&D}iNg{t^ZG?yhjO z@s9ZGUIJjWfNh}4(wTGdCzux4xwBeN=`4azWwJx$yxTz6kSDzPRn^*O1){TKT@!v~ zEQM1hpUNp@(q+}r`ebHu34V-jVWFo};CT2RnKqI=uD(?C;JocOdQIi#+q;iRk1?I? zJu|Q#BubBVq0#(Ad-RQhY#x2BDn@GDLR^0k1-QMaqn6X2V3&a5W9Yv_ooWGl+!zgb z0m$gss!=7d;M|HJCq!I+CMWZjG?mDxS((icUznEn44KrU(a#TZ;U%)X8CaW|-Ta2c zAa&QtvJ6yAnTFlHFpLYzYRk$=q<4^=s(80(n^L38Tac>z zrRw$~t1fdi$Nb)O0h7Mp3p%azHyyA5!RS=@3~*fKy2;DSTfs79g|H?H`m+-rq_o>P zDQux{cb^}KGi8@5nAgnaxO++|V@wj+xS4;uyp}3)eJd8K^hv9D`vUvVLq(Wog4Zt8 zpfpTEl7xJl%)Wkz+K=Ts*xbjZsyz>k%D~*ZWH31-3uM_n?rPX?-}Vp+KL(CDBQY^d zg`ht%20A(EeJ_4h`euA-OJRI;ZWgw2w-^yyNN_LyeTCh58r5()LZh7kPA^!5IHymu zhg9*?`!62xW}51$0tjW)XHKV^^x;iU-2J1Cu`7vGlB3glWMj55R+Fius&JR*`Rk)Y z$%@FsKp>cx@!XbY_eIdaFxX$Dm{NQoL~;l~rE(Sh=ztpj4{*2cM@lCXd-TsNqF}Vd`NR?{ z3NIU!ANe1k%*VXu>kr(be(?7z+xkutiYwy4$aWWZAjI?Hf%8Ijz^AqF8l%IXPUqMB zxsyEyd{XkVy;V`F*gpk4@FeXL3|7TYx^@vY2UCRqeQD-%$zCb4@SM2Qo~D1vo2TXv zU#hnW6-zSwgGGk5HnITzVoY3r5Z=;A-TAem&{MbG_t!wYV}ac@G*%d7ZaN7&O3~9k zG|6KdzLyQzl~#043kRNR?8@r82nC7Zv zTR9{8FJFFi*+8l@+1Y)Yu6vCToaC=C9vg0kxR?o zo%cGV6U()rM*k6PHLI_FA103p%C-H}D94SwaI`+vJP!KSbu|^U;MQwF4)PTskA(6b zeI6EEsvZwPTpUpL;MaZb1emW~$7tN<*JYr2Kl8lV8tB8*Vwr{dPN)Q&7bi>`-@Zv4 zE7xVcGM@*Wgo~G6NB>tEi4Tp=tNb}%Jlh@4)hr`AStl#M7|pKJLuV+7uH_{YI7#fC zcRsY#I(iv!Fwb*uaKdxGPHfc$kZ;(hi8EGIjiSt-Ux(QDb`Nodyp4MBe8nD*h@~9j zO&LvAZx7e%xF&PmV(9({V=H3rWoV#A{9ds%-=}wamoDYZGx>Bf2L$^rfsOnfwbs~{ z|Dzjej!Q!Ik1>js4b zRRl|d*OAS)j+ZrKJLr&!hkAQ5;7D>N9ZzB5w@VnLoBPWV>CJcSr>@Gf0c44H1}MYx z^4C6?H}Y4x)hJ!$Jc`>3ib96nl;0@#)GvCki?_=462=W#7rAL`{@{1y%P@6vmot|H zg+FUWIq0JePS-PKX;8b+bP2gaKDoy%ITk1*zuFTz{ky4q@s(=6cb&k~c!7RP^@YyC zZ~EcmCw=NMTypOYZtS{0!5(u7)BdE|FFJ0lx?`3%gdh*`oLy$zg|xa&3ezxcWd0AJ zDeL$@Kxlp~#6Ru>vk(mM%CM1Ur^d5FJc)% zpdwuWIx#`HLY+TUFz66tR{b=2@zKqP<4vBGe(MN>Ychr!#cPW(Bvls`b8+a|1Af(~Y~MzMn*I-&7L4{=W2%}@&yv!S!NS^1L#z9)Jv(dgL)P9N?}=3Php<~=twfGVo9un zKA4oe%t+CD(($UkvqtrA;D(;h1uEuHYDxe~rxw)&<_(8(kW>-MHw+}s9w?*;7Irdz zcoBFwW;d}9z3;y+uA4;jpxnw)z@)&cZqF~_2sjw(=U4eLC&^x4O3>UndoJ|>y93AX zg1=pK3v-a*xp2Y4w;l!8*5NY_t$(6_f@Klk9Ap0lG(63Ae!nI|FP4_9+Czy zX9{|uK@8CESbrJuZXM7l4Z+q9MV|4Oo}BOVVGeYZ`L0*oP<0YhEUJc0ny$bc= z7-Omk@SoZX@vbh-q15Ct9ruO7y5gLKqb=#ZH+7kN72+X+Ylx*RNRK<)$qi7*|*c2qSYyti)B)rMzu7nx?OI;(>({a|k^M~2BLmP* zN;cOxq4%rvjFY$6DJo-Ch1wcHWuwMTb{Yy(4Olnd zbl^2Ia!83<744r)s%GQEdw-?Njr-|{KR#`cs}f#i$y(7#Do5!trqEW4Q}5VP^y7*% z#-^@Asy~!>*^DhPfX^2;>-X|?6y1019^=gNJH}X9h&JZMu&u1^DD+GEJ-av1W}^kq z{{d2TCS=4oj4NKzs2j^G@~rN%E6P?YWx(HU;L^2u?ZKWaY@Cut#ZAjn12I*pMsz9u zicUSVp_eM-Ue#)jbR>Di(f&9`uqpm|zHq`&1B6y7xfsXY<^kybq`6<7OiJ>b58dG1 zLrK2mAgwwH{9R+zR$@pc_^PEOsqffMaeN&>Dx}b2@dd#SUw;w(F|jZ#`8SbN6h0mY zgYY!|d9j?Wpq?qGX2W@g)QNcbLw0n@JZ4kW`{BBL=cu{Fmv^)5+Fm}S;$zQ@HIO)& zwN_Z~PvhRU&nrLB@0nRfNuT^%EUjZvttf{A`;6%fnF1o$Q`sG#Fbi8M)OVLiZBfB7 zB7uU&QbSeUY z9d%*Md=~Vwy$J>v227kaQ-`XG<;jL!;i}XJiwHS-mw*qleNVXdVJ73BTeU;Jk<0Z6 zonqBYniGHzrjsj28Y5qOyf2ntv~vk;)%N(nST(BeK>N|)R5gbNe;>vjN8?LH$rFdK}U&DS&>F4uDtP`%t3H^pOh**1%`ixS2N|WsSQ68 z8RRa%M@=s$9Kr5)s9FX?ezYsdxIq#4ex(RCu~)1VE)5rS#@o6128?MNdqIF#p@nsO zl;d7c*ykgQ4~h&h?uDe}+&#+-UxE#z0??9e@jgalj{*%}_kOs^5pI)ElgwXvc(1Z@Ey^Ix4U+Q z_VpoF$(FmEH@lxVEF-cu-hGND+SdYYT_xRY3%~W!)$TUEC&~RjMPwyi1gUa!1-{e z`TFz%b68;(nIRw!RjrKmA;XWNPa688o^#G;@6`NLEPRarNc%)>62E zrh7d+Ek5O-%EN%_!1d(uig8T)i{2AUn}u`!OHz-Nx70TnDa`li0=@%e&&)xn8O%D- zAi#ssdktBCt9(aN-(>w8rE2}a5s*t`>D7D;O(f|QASHg$#p@u55ssB;eA3V(9>EeW zq35Dys{_t?h5itdzE{~I!Tgh}AINqU*46GWdp71Z`dYJVe7|=>-~;_#ZB=CZ8hsMk zc*5ZbC7`6hX&vgqw$_>z4;lGvL%wY_UBY^SvX`IuV%zWR+jGQUwgj)*&rIzJ9xCJJ z_+p>W5T~zhPDf00EQ%k1cIwt=DTVSyIps5iR&BfAbtTkW^BuO3bYl#Kl~4qPnZ|tL zhg@V7W)1MIgg#IvI7ZX5XAXdc$-v&%N8nk1OcS7J(cQ7_r?59PxQ z!rc{l%tTM;$l#AhNB^sxoE;>(co|>{Ep;d|O2K&R@Xe>5dN!q5h7U|!0<5*8Dv?*dy&);T9u*DZaP<`UsfO_X-Y&yUv+xX9SZ8hR7fbG2vm_Di2wBM_>$cP zeVQ81dLp`*8ZiWzxvt8uJ2lu5BfJdo@g1mm<=MB2qq~P00g=rz+rQkdOA4oilF)%i zmy}63DZ0pld~)Mnsj)blOcp4FxkRoFiwLkS7pfo*Pb9QZUSGsvashsS+^L0uGq&oY z;7O6XWkFtmw+0Kna@nviGXC~LHUWqI%ftv?ARS0@Om^zQSgiB+H5h?rq3MdX05Cu# zXNmqX#T`{N83&0yfbYn}DE-J7VfU-$CpaxrD5LgQzJah0gc=a|$eJ(*d4BB;eq4P% zhCn3qa(nl%h^Krd4s)py|DnZO6gXIONO1N>-XiRdk$#5rwKF{M$&JP6Ca>G+BrTl% zjA;gNd*Z=q0W5+^wU%e(ubrhS30`iYCqrW?=2QlR{t;)}C)9+qbLrDUB(IRIbLQ7gmvm0_XCQrv9qww1o3)*sm_w7-cS1-T6*^%#XauJDYFmvCMXXzcv)H# zaCCv3l=C#H^N7<##q!LO^(O=q$DGC=$X5~dm4Q@8fvJfU`=UP~mWhiv2QSM0JXo9~9p)FM;fN4f~=3k9bN zqoZ>gpqMOE0L>VWDWgk- zWQ}-rq*Qm%fHRr-I=i+T?HMWVrk|RQpco8UTF7UF6HhNW4JH^E93FvqXxTjm>3trm zZuIe)z&rF<`vk?FSimZI$PG7EMbtD!TR^a5Jt#YvQ)DL0){y=moxUkgiP%Q!j}c40b4X}>=l~;jAKM*5 z5h(V!jFe`g2WJn9C^0S`xl}CbvB)ve0hb+MmtRINh3IJP-Nf7L|6^Yr-|1MTeGm)o z7nB-;--!`9n;bJ+L|?8H3jDoCxQL8+zz%hPC|PwkM!Bv5kbF&4KRcN^(6oN#T2$vv z^0Clt*E&L78h)JL>K`MBy|9_ryJVOAJgu2j zO;jd57+|+3zV|M)G#5FR&Ibtt=NIo$0q>H2b}rG*pea4Ppj%A7YK1vUCGsEjZHG!O zu3B8ro?Jc|3~-1JfjhFqanH6;D`Hdp1IP<-fmY+&pm05IH*<`^d4IiI_nx$z=J9Lw zh0kAR3%ip4>72PJ#3%(qO4e4*{XME7bGddo&uo9%K+=(`J8dHuXZr=O5Y^@7BL(sX z*wD@o;2l6+$Ekq|29c_r^8~wb^<{5Ya`JQSqPm;XHiaH#!qJUSA9zYJ*XYip{_oLP zQG#YrNQa;v?eU;SzVV?~J|oP$*FxpkI@lCgT^ONqB606zPR8<4;wv%Gg`gi=B{ZSK zL3pEqWP|sk`1?;i#jKT~g|9Os$WMjfR2ab6y;1%*_H&dlO5zFI>*>Iw;H1q0z`y@+ zf%AhSCZtL~Vj_MzHKXOGwZZuVX4~4cycap+6>By5ym`-cgCI!e`t9< zE_abHIi-Y1uU*R0wT*|aFtREqS9qzQH-TLEALzT<^T!f=Nx!i}fx)huA6HsPaw z7!S-FR|1!uSHVIo$~;05-lszBZqr5P4L%E+BhorDcHiS8H8IZp{JWb}wy16=V|@8T z#4qAgfa0IxIZy8QVUet*4-dr_q1plbNv-U0u-TQr%LztmFS9~Fe$K0lSlf)<={nSM z+d0;wxKB~ykUW#1^~yz^i5UVf=<+D&gdwi~vCSRT!`q~;9CfTybGHA^JM+85W~8l7 z%4@a#`HSjbD)+vh>;B+stzYkw!^aLG=k)w94cU&Y)8#wR_2oZ7{A+5)7_zI8xbG@`{8h7fkjHNADC=vmUY(eZr?^<-F0Z>Gl91&PR!^9belJcB`M5V zs*R4CN;8OCRMI!?{i&dYMfrb)=gWORUpAXjEF2q!?oyTn_vWjd=u1`h^hcaIHxB@1 zEQ42s>y{|j47M8*171G&1SUwtQ6yHT$#f31CZ381H3}>+o?bg@_W<|ir3*2C@Wjpm z!cL3}=Mc9{+^eZN7z?AiyO)&GNDY~BUW=>v`Ts=lU1mlKq;+kX6#)m+M9^NSV&ehX z_m;GQ{HjUKAnBS(`aT0O$#?JXWhL4TwyFB}5Xl+I<6;E*iBvM;r``OUDR8!ta`Cb- z6dBYFF)!=rpq3}C%S;sQrq<{4GPhVyU2f>n1d0+&Mx3d>*t=wR2%F1rA$~0qS`^*d zC;@<_KEB$WyaV~4+Voq<#o!4I1~pnb@|^~g^4=<%l43aa`b~?1&hcfPq?%|G>-?)^ zj+t;cU>bddu_{{xef72`fjWl9u5s8NU6YI(fSyHy^*Nr z4*-uFIzc75RW*07GQ>$5wS_X-um-z$FxqbT9fp7}!zp>I(mJiTSz0dQ16rE*U6W-s3Hy9~hjz%_#5i&w)hEk(rqxFY?G)M@@ z5Gh3%I7({5s1e%$LArD(DJdmVA}JuCQX=U8+4Ewrm!Gq9zURKLORzfnSx8W~uI!7~ zaU*=(xhG`ynTRF&`U8CusB{6CNGILw5bb~6W8v+nt>_DnV5W?y>O;Wo&-T#FLW61U z@Ko(=c_lwZ?JUoDYVYLI0}z6Dgcp5QP_RZs+vR}FsV8M7+Jk#0R{HS=2rd)p&63x* zxED_;fu_Z-Y(Lm$Z}(Y(2!6e7NQQV^k<9a{j>WW9U(iVLSt+y$25op789u;$BJjD~#}>q~B^u+g9hJa@Z8#lefsWDIVY$ zEN~H~<4T(nu6)llubt+s@@uYf{{Biy=Meb-p)$nJV`b|b)Fs1>Pt|JLSGKjnexvEm?&i$vYtOul=W@}3NR`{l z6Ub~hKg#=9Rs+uFzhsX9nm>Np!gLYd9GCEzEOVz@V04MHkpn%c?2d9bV&+=#Qw&^~ zXZmXTFP}4U@rS>xPQt$=Fn2aexTfYx^1m5HhtbS}^+cxw8uEr-yzZ!E8M->?#6*JsM#X{EJ{8|V zsJSdG*0z!32kp?VZDS*p_+Au6%TX~XhDh$AVjCy1!ahn-1Ua3~dnOXSGhflDY-m4{ zKix9zPo>GZ^+TVX=;%kYT9M3o>e>T7l&)LWJUa}Aiw>Z$X?ul*{rldDG_LR8{{c2z zr7a`hEU2A|?Y)RL$oUURuMC;`r<;?zOq^fxw|^SQEoEeNT78-OsE?-Vw42CMR{3GI z(Ss52IEK88fAlS<5HKyLRYo+n?5+tj8XgbuJxBLy?qH-p;57YpD*Mp&iPyN z+vTsp|NK^+k8GnZwEqu~HUFpMKol%CGd6-zcbb@HytmBueS0yS2=hp>a}L7)qBLCEoPZ*5ACE4?CeTu&&O~n4nS?yPT%Zce_R%$;h`~Su6 zRA6sR-?jCdg9iNDKc}P3<|M-}fzBJ{!3~!#60WBA0)NupzaLt3nui_~ClRS4ja{7A zYS}wztk$Ij4c0^|u1_?)bIm;{B9V|Cd4Cn$Os9}Pg^!880xO5oU#%ESX8A# zrPQ{vt1~r+zL{Nam_FCMdgFR~3*)he1V{GXKa%~@%NDb;<;w%r)gPXo95~gv`U{mt ze6e~RCC(L9Yp+HMFM9g`F+1Hpw_&6=4nA;R^IqT%!u8x>tlY{CoCl2ayg$=FfTX$m zbCe?7oNzIY(%Jt5@K+u#-ILl8_PflS08Jk8NG+qwrD zDE3<|tfgYE+lKvzqRN}a!ND_}B)M(#%i+r>1J!@aX_TbBOy|JQZh!y*r8MUC6%H@X zfso0UHdVSlTAs-tGThmKXX~-}w%(0q!vx4MGx?JQQc!FwW$jhB+T=~HzM!_Pk^l6^ zrD-jv=g1{rx;BL-Zt>XI@33yeU$cFkFZn%$Q+WS6o{1a}1k5zHsyH?69Qo%k?|&Bn z93^-?Bp}Y}crzZszQ&m?LQ~cURZbt&E!Xr{2tVq}S{WQEFMiADX=>3%bhg(=36B&+PMRmTGncRcm|WW?IH3+QdzJ?#;=^Nmm3kIW+=Iwq5UA zW>>!S%p4J$9x<^-fOSZL3-r^-Z2NrOZ0h=~f6ef=%)+y%>h@k*jo8M69@0?V_Cq3Z zo_Mm1Tu@uNtT9Ahk12rua>pN%2+=^4z76dJR#lwijHClw!qx1Ym6-)~VCVMF$6KzS z)XD}1=4+f{$7Vgh1Vro$8;H&$^bZ$h+^1AkWxwWUDam5vD)K<#Qh8DA4f)JGzKTVo-+Z~J zuw`sxmcBVI5nocshsyRQCshuxu4qv!HqeD;XB@3Ot(7~>bbE9Yz4(Di;A z`o^{E4^#TogwlG}==aG4K+m5Ui>MC+#I;@Y%d|t#XNrdV^>L(gz!^%XJcE=X6UN{Yp8GgR8_s?T!mGU;2e*2y_5S@T5 zq-u=HwQNeUol=r&MtFL;!lX*z5a0M?^5?sioCdNg0pl&O)G;Y& zrtM5$!X_;iVKMxq16;J$zUb>AN&&L6)b1 z7=sy?6_=rHUy{n<%}x%Dld9&_OGcpaEwkVjXnJzBZEU{V^?x&r zbKrIKeYixj_M|T8@3BzE$POFN)FkY$&MpE7YU(9eHQx>6hyicmqi@6}^BMP)g>J+c zqwhn4j6lX3-lqI z(k1J+_tn~Ouh2d?aMBe?Bg^68wMfc;THa`woq-2)kzrMvJZ&1j(au2bBXrk;nV@2Saq zg)Wc!t(^%?x=aU>#t_F3PHKg;9PV2#2<7?D=9~CR0Cg3!Ug_mD;n(YKNKsl75S*C6i0hNL~q`GdJ{m8IV^D58;cz$}mbKXwb#^^3y+a$+2t z&_~ER^j3J(g0d&3ox<}oG@@FR(ZcIT+B_|E8-t7jtPm_*BDRmMpq`O6w!PU*#GXot z{iBr#{!rDB%-sJ0&@ma2ffD*Fv#7=P{A_$Tn8LU_A>`I_fKcZnJ};9|21r4ERpVIB zRq|{8Xk9l}&A6VMJSMv!@qpWU_#5}&HoxqL2RUAD5h+1Pk*TvMPxEaJ62au7zN~K< zCfYdJ5B%;W;8k`Hwc%%S{WTH)L^Pl{p%AMIY0vy(%-C{*Ci8e}x1;Wa?7+C%aACuj z#Xy(w`kF*RKuRqpRP7SScS`G-F;jQwDKGcba?$Niu#ZPIR^Q)TUugZ})!&8Qt6^V6 zP{s2W<*prQ*#%CR)(_gJohFZ7i2_E)6iADG;lHeSU-+8ry>n}h#n~!<^%%wGY9_Z^ z&B;n5kyei$5Xx$sHvWyI%Udoj4sHKg^;bxZ7(RQ69k(by$aD@+<{3$jqz9yT_%}6* zoc(xfnV`bwModap&oGG8QU5E%IJgjg+himyE+&0yeXH5c|1?0Uy%EEvT9CP~L)!O4 zXWy0ofRteF*_Ul7cz=1(HzJgQ%3-qr9RM8RxBT`On!ZOiO3@__pNN0iUCy?nplq6Q zJ#qkt2YaqdhQDx#xlbLk=hx3xNx#N&{P#1!9Rc1}3fu^$^-t2hEx3 zMI6kwQ-m%7K9p zioHw3nMV3p%XU6F3$ZF!EN%3B5&~H+G67J@`h`|welyBi1$E({o~9_IO(zIGyRlO(#y?%utu>_9 zl^q&w5nxufW7>=Jdw#n#IEW@PbNap*egB}(<+||ClWk|7k7_<#Gxmj)$_+i!`eOX% zE-8D$r25+81Tphq&pfy1KH5pG=vnIy{d}$0QGsMeoCcNX(Gj%(t~JSfd%r4q{hIEP z7&M=}v5{_U_`)S$Ozbs3C zi+(y99Y2@lZg|VuK;*%uZ!Jl}8y~#mID|VyhEQ+qkjJ+B>J>c;1PL$xlUK+P#@7m# z0awELZy%VA9v*QH%UBdc?P5E;Rbqhe zkB)xZ^)AY_n;NGSg&etNb^Pe6z%`Ytqbhal2~2ca;(lWD`%(w16fVSC1>{d{DTn#V zu3_t8?H@DaLk<})GdEsF0|faswVLivJ}`!0q1dgU@r9sHA-e}cg=Sx23aQ>BRs zy#&1_h`Jj!T&4yU}pNGa<05gxOVav4JE)R z#9bQq)8<}g=>GspcbIprQTr0BWgkHzJ&B{RqEYB^^`rFoeDzfrGK1xJwXF(Hr@FV; zPr9MghpF&n6OU2^o)9CgW1iZ(GWIk1xpirzCF>Q@eO;|y)|HV5q)-z6Zt9KdKQ8&% zXZ;D3pkk2C*Z1v^NhB7N&>M}9<6u#e6^v76!O12OHJE6^Buv7J=lZl#Ho%;PD3^lo z783f-HhxN;U(Y@;{S{n(f%o@elHlRwb1}yr6by9VZhmZXfbNuq%>3kM_$xtz;!JjJ z1b9mR7GR&;5FI>`8b>vSpFdZTfVd!J-Ce!;Pf`!y<|?;Ce100BtK| z{0L8u(JiNKPPccc8oEauz2aEA0f}iIL<-@U^&K-DF`UJWi&}k^{NEUhG2!_WiXqr1iL9vl4~)3fwZgz~pO+C$o-MUc{HML+g=+n2@$D z5wu~7kF?lyza`SH4X6e~YJ2}8W~coVh22ZYm%>={^seR*jR8}^H9FZ_36@Nw zLfcZi`x3_LrLKuhvbw7o87yO((>lEXAPvKXZBOnY#O!o8?nu*rsWs|@-H2h(qzGnoZ+*mGj02;3E_@A37TK&+{bYhW>p>SGHawm|_>Ny?22?#A3!8|| z*||!%bysQ>dT5M>A!KjdUfNT;n!F8ZtLU=2YEF0|VSTe8`-^JlMm^CoY?7FVdenX?_T8=QK z=AIAD*8$>d_Fr{}1@nM{J^Sn@J>zj7N0E2AF2{eOVO5*ArJ?af%S+#8DV;leUvM#f z_OvFg?&r;#Fa-$X=+u!DrCv!D zkYHOcw1C?$-*I7*ldALADr#N!{juqG!-Dz*pfgzf_D5ZK=d%&6*T6A<;{)!>z_*@@ zJl#J+(B;ms*rZ>K%s%2d?%}on@Lg8}eUIh$Kg?n?l05fSL?8R>x85Iy)^H?P=@^EI zZLZJLQO~bn1TP-e+V3~-x+O2dA+PLQ+kbYxa(G6IJ|?rqrzIA${o@aR8Da3uuIYSz z<_cepAf1kJ!-4%msG=|jUq^`)yes@q;&_XHv24Q^&vxf7ipyQkr|Ls}wt;1ZoV`=~PY$B&X+lSL(;+Djo$-Rk>(qf{_tIff!L zZ`|5!x+q~lKPB1VxHY^@{we0QQtks*B|#f_#f}~FITt{$)V0wSd*nZn>bT>v>6P1` zuO=6N$P9||p5&Mel`alJw1u_IlXm@0s!zECAH@7Fi2c=X_Kn#eccnf z=3)zx#x{%Ec!({HdUW)!)$4i2WFMf8Lc~CP9`A;C4t&Z((T$Uz!b~4C3WVvR__nqQ9WzBfL@7F^LNC7I}lmHJl z2~&KD^lB~`XOnHS%^_9|ni4L}&%9Q#@2}ja?D+y)J^)SeB#_h#NRK+Or^HnPiZSC= zfhH}iUNNNWH&^T~%hQy#hDYY8*~cM;A9{Gld=u*#87)CmOI&PJQQv^Hvy4zBS^vuy zuMAo$f*uTRJ1}xL{S=R}{mwuQX4!=MR?D zgyn2@n6}(Uk2QzX(ki2MPg`9`5Wpk-x%RJ>h7<AvufGyL=6_UZz$M{0Mwte|b^DSi}M$9RfY1;-#vuJ0T$<{P&*C z_qYNNR9C+WCrcoRZLdLL%Nmq2Mfa}{;2L)qmMQM^2rE+c4MC7HqHq+g{KK7-F~smg zLt*`n2R7Bn@+4n6(MFMRuS|2`KR*`tNYQdI|79+&JoX~uSLCSCxEU|2IhD|KQg9fr z!)B`#2UOOwF=2r<@`A)M)(<7~(|WcCiC*#pyx7#wPiW8yM-S4tsqNgV*Yk(@J+ao6y3hw8L2oSt!Tj{TIZ<-bYgs~8#Hh`&Asf5nFY47=xg7|)!%qEVrGANg> zG}iVnqoIaP>ozJ*KkcJst@bF}Tr%P4Wv_9w{Rkt!PeahE5$BS1g+7$vSKC*$x~UaHr{<70i+LsX|e(}Bnc43pi=_9tVGH0uUN|94XLsvj`3!=fv1wG z90OA)#Pb=?{H#S<(d6|nLx`)FlAfkVXpIpxUs|Wn(eaWea1TXVn0RD+yGDPA> zs;~TbCn=P*kW1OG1PQEXvce!GvOBpA`Zo8!^XlmJ*?*Ugbj;GzB*hF#FDL1i6B_#j zYAjXadsI$^T=pBk0m8X|V{Lym;2;<1dm}Lgv{Q$NLDEtuEu|ZTk#svIUgM-AN5{G5 z|E`2rJ)93o$CHvJl4&iWf>T8{3)GW+XcKUmVk61kUAx1ipu1?B-9G~@^mx^5n&3)> zwn(P-%E%-+uC!e|JFA9u#9N7yE%VcHA4K)_oc~i1_SvAsi}&=q095TDw``MWo4Va!iDTSfKgv$} z#pSD!&u8b-UoRSl;tD&TYr4D%h2MMD`pj~m?c{>A$9JG-I_$pDe>EvQ*FZ`7e*jp- zDWmk)wSScqu4-+;^)j%avkGPkH7m`c0#|NLbUeQ#c$eriDNnT5JXCjB!0eP$YX zoZr#SH6ezCl#6mJ>he5RV@ypmp~i)bqCmx{LK?U#Cv|pF+)PGn%9L4whM26lL9C-~ zwS#6jwQ#|*pYGobl~(OBdf&AtDp%ybVZENIc6~9PEmp`Kt0eX~$N34*<7s;i<(-WV zW%U8)+L0kZA3{Z`e0P%4d6gE|G2NY?UVI2yP@;4^$* zo&BCyJCQvy)OEho8!(eJA+XZm!;PP;zWHHYtf+e4YQFDwkOyo5KyW)G_}!ENUgpMk z!4v^1HUKfb86m^e;Dtdzzj>H_98!D0&YW46+W-@(5+HV*YG;=5kbcGXwuFoqybv9E z?R{Vi^i(x#FE}b83^)CxyY_gI$7tsFHhK}khTtx=Z^r2m?V~^3_zP>r=y&yNPy$=v zX;@M~mXrZ{$d8G(kX5y{jJc%QH^?*kOBHVEs5m4ze&^BJig&HqE8OF3PO<-hiy74b z#8Ku;jQ*CH(05-p4>_iIUEMjV*!#1oxyCPL3#Q+P**mrAIX3|hoGeV^M*d-p3 zYnZ*vsVaTWsKeXppOE*UPxbyBpH$5FCW?NO7;rVA%&z$O{C?<=&DWxQkpVD$88zFE;9!p)ePBses9QU!WdVKQ!Ko66ptE(y02 zI33%7^Ko&ddUifju@prGFwKlVB)7_EcLIJcXKl=JcV_38t!{>NV)|E<{aV_Bq35e4 z`K5k8G*MqKr1Yn29koD;wkUo~EyR-ejI~$e`kB2zWF z>I-n1=-mAFoHP%*N^_O=8qlA14g$#W z>Zku^KpDjFG@)X+Fc@pxmU6{J70zJ}5b~B@CPANW@dZiGNJNaYcG4f=N24WdV7Q>Db*4b zvFmHf=*`l=!34hFtOi6J=nHcma_M$`+!!2Kvt_v}37U*b(H<%8h)*_z>-J|f@G>2M z%f7MRqK}^>c}r=c3@f+)vKn=uxSO9GtCF3H8DlzU@+J`0ANx6-!Kg4MHIIV%Zi9k7 zlyuqm8~S>xAAWh0HdC*RkDr%>Wn&pb-B@kU^MNP&V35YYvMlP$vsa|;CZsHh?!cD;Gz?+K$ToOuZ7)Q;H6>b;)Qy`+QhLh47p6M zboOyLOGb(v#XBZ^F8O#LdLlB#L&K}0N?@Q?bJqJx90es2&~TFN2Tk<7u@F<&Q(9tb z(OB*Fz|qPy9VSs9XT|3#ySACQTuNZ!BY3x0KP&bu4 zy+f}TmDfyZF%R{wsk!JPc)Xr70v$DCeGW|fdZ_f9FN4>^4oolTI~eoR|cnl{_27yq=CbO8S~?qdtPK z5b`V@d(kLD$6P&~dTZZt1s#BtmbBsvjGv{1S_wBSC*?e$rszc5HU^&4MccaiKLeu1 zyB(8+B&@oPOoLjF{`TjEu?6vMv^K;s!t&fX97JJiSMZyjiDuoF!0dg$6a{5w+>4%P zj{j9!xcUR>Ff=yEx*KN}?Dh*lMT#CjQvl)Okr202o4b3o*Yn;DvZ6_%Zf37-?jn?) zj#MeXZh%eL@&&Mk<6niWc+c4>bJLYp-eeh2-S3q*(nJHE1Xb3B3ZfGM80!~Lg225V ztK`Sj)i7s<@z=!U6`BQM__4mW7ftN;FK4lhZ%jJz0HtzSRpZfqFE2DaCTH zjKwsx{zn^T(H=X(lK^18(jrhPD7xVvy86)eYp7y9AkZJH`{|zk!k3GgNFmGFERhf6 z^PT%kFRaHd&q~gnUzrY$t%y0tk15X7e1EOjA=Sfx=xdnZ*hAgv_!KDGyD~V=^f&!O zX2oFoOfKJeb*H896Q3TzeVhDVO$;vh*Inerd4jUu)6tO z{$pjtKRA^gw7KykPl`x8)~IwWpd@#}gVbM2|u z99v#sy%H37YP=iobU$k(=y?)TwM<{sV=I)k$+x$RzUKAEETRznBwceB;pPG0mh8Xj z+!K9a;gp>1L%Vefebl_s-5uG%-Q-c>Cxy%f`3LCjudRG-_B$yO^0^{{d@l2+SV|5X z9Fp$WQq`EfFA2d$`;ByB(q;sPBIYU~1-lM&UiQL9o1${Xkk!;Uh5-z*s5a4l*$q6z z6)H)R>stAz_RLZTszGS_29&7(V~yp$_rs&s{?n6{%fHK`bm~Gh?)ch%bzpu|siSG9 z(20wG35dORUiT(l-+fA9)GzartoNU)xA$>PX`$=ybEbsnphby)&)w_&6mu5o1;Vnt zu}5!Y-8XihV^&Mvd`RXG1|&`q-MflYoH{*0_BY+l1=Zdt2f-B@TOvDvJ-o9P_JVcV zG8vD*q9l1E6ybUzv(2foo&Z4Ia&E}B*KuQj%+L<44H&vy&#Xi9Db{W-g9;tY%yUo6Z*$~MbBC+-$w<4MaIx%rzok_Fw+!4xGq-C_8>-Mf3a zbnvv9>z_^I-m3tP)X0az_9t1OG}eCJkMhI>1ov`g?U+q7a^tC82;;W0bV;=f4q(eX zptDUQ{7d+$!M7{F{$zk(pP=4c4HgF zo?GRLyLZtE;-F|R(9^5|5PhEtw@TYua>W(|6nlzdjvgbGlg;5&Buw zFN>OmJpXq0eMXyDrOF9e@Ld)ty=GLx8kuFGS*krI<1X5QgP!7VX|-q07Q}-R49=}h zOD}zV?K8R!|%qY2>YX31!8Vv-0C?H=lq$@*j?S8%_3{@p}w zb&2Cqx!cMi*2@hlnN!UYkXp3Ga0UJ$*-S9KQ|-P6@sXDWh-K7diPpJWyk(HdA5IAc zM$lDOrkai{FNHaX8@5Ow(D6Fk77IRAK7VGT^PGBl5TY`X2zR|D>HJ%RjAcmm0E_>F|dVEy3o@1i#YYm=ead@ljR%!2RA3xE`M~WO_=Y4?@?* zO^`~Mpp$`rm#K=*9~tjvRbo3FMT6c4O8=tp$E76r$eTdKV;t)>(>qA^aGGzDMaM^h z%^gBmO^F|wtm;M*e4a@2TMRAf-E@C7;5rk@D3#DYLOlod{i=x>jbn@7FBl`P25@cZ{I%U}@?-%=)wp?xr{Pyl1T?=fNAC@tiWs@8n~k8wBeoL>qwKfk(bN8e5|cZk(wBqUo^a<PNcWS|2?=^#f82>IIHxMY z`n)%j4pPhSuMY_MTkZ1FfPtaB7In%vcM-Fb7hK6URQlYUN?NtLm5I_AAn8MtyU>y1 zTx@?sOhnstzSSS7j0`;XMX!lGnj~>W{0e>S%K{sCaPiUM@;_RZRE;5(j#HekuxHyY zOhhEp;1*a=eHYpGU~M&R|0%Eje7UsVGWL>@c`>$jNFiBG3M`-?H&62%_0T;x2}Z2v z;4|#qLw=%bM6&lR8g83|&#Ijxx~eAGPVr{1`X@YolFf0lChJkpbf-P}B`i-)DvweC zana|KS&ZtUn-qB|nQ43jI5F|`nCKqqS%B+?UAi^2J?q!*4sN6`MD*H_GQ3PuoD)Jc zE=Xp#M7(4e+A|GWP2VZ|y3nik4yBw`D0!=TO*~O<8kKc7lCZe>ymKK99ki|_fqp{a zi}N1NKfukwe|7iePpT+Met97*=x#i_hUj*RgFu$$ch3HbGEg|bv22%8 z%4)v0eBpFoksux}k&Sg3?@$z*8o%@QxqjdpQzcTJ54YXmpv;7E->HO-D@T2Yy@tej zqSL5b`{cP>yoqW~70@l!=Y+RU)jo1XACqhn)kSx*Qni-Fb;+v9wLwto1jE6&SCefveq* zX0800sM0285L5n-!9!GGy8B&EYu>%srm2^2zxpX8oV5+S&io(XS2fYw{q?U%@aCo1 zc+>mqDWG0+#D8~@f*bBzp#WP(btmfo08-WN`e_By*?3e)o2&{Uc2wsh7^g%n#Ljx~ z<}{QW`Yd;)YA9sSccbeSd_FqTeHnp>o31||``j3@Vq4*^4dcM;72MJzO22!Xo?%#8REo3o0`D8w}*SmdfhIV_o>7MF(T9$ zlWJXiyUDi)F<%LX%fRtim* z>GTO9XHz~+y$jyw$`H{V7g2E6D*8o(uymEO-l$G9dqI=&VhJo`a++|^lJBz)V?y0 zxCK*!X7z5-|BGcEU%;&mHU`>AZQeTIy0XSUfq)T*;4zOt5x)*cqFfZUkZ11IU>YRbo%Cc zI^rGX-{b`hBX*rO&MkGq&Ab9hZLxVJ6!z9o!L$ZmY~4nmzt^N^L#@E%&VSbHf+OjE znRWjOPuoOHH9k>M`GgJetzDE2c?Q-YpSB0=IBFvt2QalPUdo+SDHTUu5!|bE+-(V7 zFR0+5T7~<;P5|IX!z+%DGcdE#vQ>)aJAyB#;q!ho?gC77G#&d&{z*mjT~xt%x6480 zH5l=4JLuv8MWMXde)6$j0G&%3>wKxZy9zdkpyI@jEU5P2q-%P;m!(clmS2*4bl<{K zv~rmy$mJ&)R7(NW3Q!b)yXH*EV4?);__d%#jQr?@<&1a?JaLdN)h{A1S-}oeXkfz; z|5)}Uo{^lKT*=uKq9b?xBroX?oB%RZ01~NuR72^Y$mdwoJr(f!tc6ATrW1CXLAu+a z@v6Cjn4D`6bnRDkL~zL_1|>|aF*)PU=NafaA|0D^p9-Bjp8dz)M@`x4MtvHgf(h

Qk**Zb9|dHtv-l+m>Sf37*FuMkps9Ut+9>r2gwu=rjt%W z7wzxKTO!YQj3-l5*@vk7poaAN<&AH`yT60{42SCE zbwY7Ce~A6rvjZaDP69W>=%tRmvgwsq=c9dEA(fQh6msj9tPc;PFL;fwBqNrUkl(?h(QOp%)&qXkuu+;@PguLgT$8c2g0*3KGC`{d`$ zzxjPa=vN!19{ctlm3{X$9_JGfWujs$Ex-6>A;)|ZCPGY?o=v`ZtXdUe#XFzRod(`& zwm(?drwDou7TRX8=&1?L+{Ll%+NVFV14+*p)-bQ9SzIpl-#VaR++nrlXR)l@j`!wb zG;LJZ|8$~61hs{n+=1H%pH|BsrX%xd5Dk_f%truQ&1$A=Pj2DJfGKjRPs!C0oJ?z_ zy;(8gK0LE6>W3mpD-X(Q4w+0tLOi4z;kk4LmI$(kNt=;-X&sN-3_T-&Um5CY#eP+aLmMG2X zYvXHVY-rR!KFOJfaRw-J91Z+tb2SC_5I&%${O)SQh>=%HC5$C!t>Q{%0%tqv8l5!1 zRzHi!FCPSHJ6r51CUX!%oYcyq%A5b=2efYj=eFEZtJxC$BvF+_eLe3)tgZ2}Z9DW&!-AR%7b=++?lO7i zp-z;4xc<|8jtA0!wKSl6ywgyNbO+GvLx0MpiPH)EQ7X1i^5s3lu~HfLi>>?g1K<0^ z!GbiF=?F&N%~vD>A@rNryeoXc$Q9e9?6GL;OR7VE`s4t_Vetwhw@9rOT0QCpGn9Ki zdh+$N-od>|a(5Taw)Nc3?BRZ&B(tQ}G#%v2a>Xs)I8MtMn;R@_5p2DNmv!U;Qfzj* z;+XXo8jA-ZSD&b|953{B9{q6lrkMH2G&fh}<02Sh#1dww_^hY+z?!X2GACsvay7p2 z(5A*A#5~OEzTj6}*d)$5!omr3ZG#qVPz^>N z9N5%yhH(!{J$@XGcBn|&W-5svuO}_C(Mg}rL^|dt9@7@WkksLmyf)KJ6-kzZe-u4i z*>NADe5eKmlBf6|%u`|{{?w~O7hLhG{3*RR8%mw9F8-mtdPETM%{#wtE6GK%Gh-tK z?%LG~d7I$hx^nWg)39MP2*l%=+#`PHan9r?m@tA-w+xAc)v~J9>dmYCmBx;)&e!wT zo}~r^yzAN89y)J-RXp5rViiyWOyG!OY$UOVt|x%GkBO5@-BFjK++vZd1`$MmLV{>Q z*5uo*_WAT?I}m5iTx zST0~MmtQ^$USazSs~TvIm~LDj6dC8QrQc(lG!~)V4-Hsw^J9yzMg%vkZw>- z55Ui?g*jAqRusfBddH(*$VNF*(*`hiW1Q$Yks`Fw1^WZ<18sZW1yY&2rS2doAxf~W zj_~=aMa2?`o6SfQyS6RDoD6kG?A|VBpK%T(2f4I;0s?_o-fp$F@y~`1a6&0bnIh#; zrgiT?>^- zpl=_`rTZu)2)UtIQf$5FwwUm#6qcQPP#ytk$noFp2eI$l z60Y1F9*m2jDSx`qQ{bC*!hkgKj#81)2;9uEt%qlIp`x?5$PC;H9FA52D$=7 zerdI==ySe3>2#K6L!N&JSF@;!4qAwlIAl^4Se(knj}K^tZh2QXT5hl*=4nlo8QuK^ zsaFd-pql-)c}n};L;^+Cqf5xm0ct<&Vl|JGQi85U{{ni^7L1dH}2i|&?l8hqlq=O8NGeT^1vWH~^CS6@)Knq#W^ zdpjGnx0We-Ufz7aN_dPX^G0~3kQZcM-uFQ;v zA*ynKk5`qritJCdJFDT+KJ>=H14wWOZO=S-Zx$nZ&g zM%Z%6_01l>HjzY=Q4!CNm%*Zsn_XOw-N{~=grf>7H=jV3x|D_NriLEB{SQkc3#T?V z20dpc+T_wNBT7fTW;fW=%IUx?^fc(j`^&B!TwGN&UmF*)CmmzQP<1}p{5}J+jmj+h zEK^^0NxTN7wrG$xqyK|B!Fo#vrkDWu&cMbNsk#rHrq5QvBDv}H)YzzW`ry)3mQ6$1 zZ0?i`-y45IJ*N+fLk#<{CZdP-jAO6@u`e_Z8JJ5(RZhfvv&hnIhILIO8lC)}E=j)a zD_6s~Ig4u8@u<-c*_icv+x#(_<63tWQZyfYoA&*1Yr@D;ATswZ`X&}R>HTmP0w z@Cq|f?$8c!^H_eCe@X;gGo+uh6S$ORLDvQXnlLjmdMqb}sSH*qNXE|42aSI|-v)1K z@bx`mAaCh^u#|mX}UhNSyDeFAxNHS6@(L- z(pFRhRsS#I4IT1t(#Ba*a6T#=<7g(U-e+$Dr*McBQ&4wK4knZsGfgM@K_57za$}5l zG)>TbM?ak#fe}ASM`&Ceii>Z+BQ!L`0)JVhQxgCJc%YG%=9ISPkT!~oARCD$NioS4 zFNBW%)muCm%>f!oEJ^7>Sq$7ndr$-jCTa<7(f89pQInpY{?$<^up&97xdZHwDp~yy zKMJXtgn}vv0hy(U`>HQ63OM(kwI?`}J?guFL;=?{T?y(ZF-vmb;FH^mHvm8p9cdYZ z7#&X(M5yGJ03Uiwzyr8Rt3cYnWD!}eyhs_V02mVo2dyD(tsvD!+Gd!LCv*y|(=E?W zeErnhhIy>T^8%jP6DOK1tJ~I|Zw=H><5ZV}@6=U-=ti6o!5-CB&P*r-^{CYSq``^^ zj&V?n0u2C?zNitL&95i&+98dtba)~ItF^`M`Br6txd zK^%(KGiok8hy$9b*s|x4VxUh`6H<{e`PFl~Q;;~NW08;tdUjx4N2kSc?X27Y704Yy z5nRs}Rk*CIrH42Z2iSG^_p7`oR+p`fpb0qy(`x`IZa~2}2d#Yj)q42ldA~T_WVDLb zl6^=Vm7b^Y6?h6<$n=39U-3<=wP|mXiWS&;gmtA7poSf1irwWerQyfy6;{ZZ9csP# zDnuBo6q5}R(-kJbU<{B!$9l`OKAPN_jC-2vXj(loRY?aO#bL4pi9GZIwOTt!KUj+8 z%D11U%jm(5;SvZ_(DsVu-?I(oTNym9b#HpCp%UA3Ao33tk+z$h#PVx8V>X%860BrQ zM`~N%p?V0wHNRD*wphE!89$?3HL~pY8E-TL9CRYLCahvzF?91B#Mk}vZ5qb%bV{l!nX3VPY3(|0Gh`qE?llb=CM4$aYp5SJ>X*Tw=Gb5b+tdI=Mj5arP0QrDG;7@ARV$vH;*@TlB?e|u7yTVAht|Typj%$VE*Fhn7z&RjvHLJy4wASTa zScrkvKh1fqW!u`DrOK7v&>l@IGp@|;Aj#&kIhKWzdR5D&y2~zhkIuB|^r*RlPjgmT zjm@ah>B{8B*+JL}bDx7a;DhQH&>n-v(;!QV zanqAk*$kGqZ3H(WuiT4li$HF2W8$GLU10Kl&IENeewecRBr;l9Xb0M@(&TV@^O}oJ zn|!yBvmpNfYPDHG+McepI`nmn9Qrw01PH zc=73ssV5QdOb|$uC)%_wodJd|Oc7KNtM#e!k``x5mf7Wi#{!)JB$7F&0vk0xl6Z>7 zwZeUnD+q|9PuU`@Uc?GhB=A0Je7kP$pd4fCPKstsW~{J-c0l5-eSi}JM-f*vw-IY- zox_T9@_9cML41ga_o=qUi8Yx!T+^|P^_r>jPfS$ZKANgbn689+sTBpHKso%WCV2YN zlZ=}CPl=`{KkBR8VoBnS;(4eddc`qiNd{&|f0~FhQ^#6hJMmRCpf^#)FjL-%10S70 zZ1MQe)8oHdQr)BOs3*NCAW;+ZiX?ZaB#}yDqTzw5k9ttTf@hOW6M#BY6WR~bpwv_n zdekw-O)ETP3PSQ?hKqnrM4V=%REXr%GzlP2N<#|Eo(z5THNc?av)yui=cLeH*8#w4 zUBDjrtitF1w8f{4Qw&?Y91=TmP)H0^o<6lgxduCRrUhW&&0H5suM8*Rk=&lONn!|q z2Wp-rh{)n-V#0AdkH1=l+|2{?s*C^$krg4x2607RO|=Xd^uZNO!2a~2U8GGHKGqLf z2}jz~GAZ|O1wkr$k=CjmbDxTh$ALj46)gvF6%)I>lN7?|NscNdL4Za%q5=eo%@T9^ z6mApDRAPJ4ObN{KMD#eCthRlqE&%5fM8=eZ#~lw^wQ*SO-2Cd~xj}r6ze)?h{HYbm z9XY6MgPNe>q?{s%?vk~RFKjH;PNI_-6u4!g8&kHQA0Lxf88i~5-1`B zv0i)CY}?N<6j*T*Flrryz&v)P1PoA0!8650F5-BDM$p666e}p;)opZ=VmnEuE}e)` z0~EI!M+TK{1|@ku^bjTi_^O(PP)24dNeUo=x7wqoBmC01DojcDHBiK<;*rUN20Kqm zjlk!SI&`Hb49NTFpsprF_oyVH1CvqaW?%tTyM|(MQDie*l_CHXn}}Qi^r<^eNzctj z*5?#!MY2nAC!E#8E7SvznnhJXE>cg{rQw1hm9^)G?gT)~a?=xib`4 zZP=DPRYb8c2n$SoW+VX}X+VRveLpl70|3WbuH)oEp^O8}epN#-Q@Q;krAUUlz!Awj zaZ;f76skiSV%tCvKKfOWW=bD!m4^F4BZKo=h0bJwilXq`#K#6I!H}_t1amYK)9~V& z-~jaPNstNu098>eNJ111(}}6J7%1F9AZC>a4F~V19CH*%ncT*#T&Z425)D!a9GU}3 z1ZJ~aix%XG6&r{=9_FC>N$khdPz(q^N{Y2lwm&*sj3NbAAAmDF(%g9JDT%7zCxec) zGq?^+QkIiI#Pl62Nl5q^i3br?F(lx7%~(icNHILqEtLjAG4st$!;I1eW*LHe(wPPf zR=tH&bOL`W&vAD)8y)L9-@qY#z+iTRnzWgKKve?}KUu1_vb3m}?MC@NrjD^j^1Gf7 zsutmFfE*rATJ7G{g|)qo?cSCLfZglKXl{jYWGINoC+51Tf6TY`ff4;*+Pq$FH(j`z z^7)x9kaJWtvu7ua(P^?#-__DOiniUn?#AEFxlW$GGo;u<65Mt@Yfivod8*X)=kTj? zdWhnst;lp$Uf30Vyk`)5RV%Q>k7{)VSdK(uxwY|a)377UXaESGoQx2TKO)m6sBn1T)~v!`WS zXwKuzQ4D&>;wqhWq}AF60DxpK=UpeKIkMvpuP9e(R|IYU08}oD*tSE4C-bcq%C4Pl z>QtT3CUfk4jaaUHxGpy-kb0WMwl_a@BGZjIvPuMXg$>ZpA2pWWgX=$eQWb8Cgd(zK zLm%ayhP&EZ4RJvR)EvunC#`q%8d0a(%+2NO#{_qfJIs6gioAJOE`4_A_$P*J(F-?i z3r>t!u~`mRoyVsjA7j?N2)6c$t6P)1afntR@(0!r)83O!wXH9d_Q8H2M3LL?{`Ia3 zgjNl>LHiqk5s!{dR}NQ6tFpomp;+St#|QP#O3d13bx^`!OqGMcpT@UbZJ|&w0nen7 zA|T0=iT0?qde!OL$+!}@9FG402m4bA%EvQPX6K?5WMM~I*QB-O+S*w9z}!KMeSVd4 z*d>D#y#&bq)n>?2e$a?B5WwzR7byRv&;3&z>Jy*1~Y+Klqn}7lt~g}n5QYY z&P5|*BDJ=+#)FK|i!J!#r9faY&0l8TWYqg+*=nGJh^7|A&1e?X^)zfqnKi7K(m!?u zh8%;*o-hyhskfy;8@EB*lh$Z^q!eHWr`y;M?NtlTE^qb`^oabcHb~UA!y8}{5IXCas<*ZQ g;M1& literal 0 HcmV?d00001 diff --git a/slim/themes/original/panel.png b/slim/themes/original/panel.png new file mode 100644 index 0000000000000000000000000000000000000000..384154325b2948c50044e1697f7c42425f1fdd99 GIT binary patch literal 16123 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 Xfa0saFV$o)^PnWBhA4UZBJlqK06Jmv literal 0 HcmV?d00001 diff --git a/slim/themes/original/slim.theme b/slim/themes/original/slim.theme new file mode 100644 index 0000000..3ba62df --- /dev/null +++ b/slim/themes/original/slim.theme @@ -0,0 +1,37 @@ +# text04 theme for SLiM +# by Johannes Winkelmann + +# Messages (ie: shutdown) +msg_color #FFFFFF +msg_font Verdana:size=18:bold:dpi=75 +msg_x 50% +msg_y 40% +msg_shadow_color #702342 +msg_shadow_xoffset 1 +msg_shadow_yoffset 1 + +# valid values: stretch, tile +background_style stretch +background_color #eedddd + +# Input controls +input_panel_x 25% +input_panel_y 65% +input_name_x 394 +input_name_y 181 +input_font Verdana:size=12:dpi=75 +input_color #000000 + +# Username / password request +username_font Verdana:size=14:bold:dpi=75 +username_color #f9f9f9 +username_x 280 +username_y 183 +password_x 50% +password_y 183 +username_shadow_color #702342 +username_shadow_xoffset 1 +username_shadow_yoffset 1 + +username_msg Username: +password_msg Password: diff --git a/slim/themes/suckless/panel.png b/slim/themes/suckless/panel.png new file mode 100644 index 0000000000000000000000000000000000000000..8eaeaf942ee6279577a1a86ceb6c6f9116e03dff GIT binary patch literal 15641 zcmeIZcQl+|7cV}92!iOMM+>5i&MB}>5Jd021|eFA z-rbS!Ti3mJ-Sw{fyKDXac%QXq*7KaR&u8!bIs5EW=9x%{x&j^!B@O@pz*AC`)dT?0 zRZ#ca5ALJBJ;g^m0f0wJUfO!DnoxIoCl^OcgdLpT)zb-15BES=0stPfWoZZ(rY5|Q z+d~p@bSWn={?vn|FWskDFH{(N(#dP|(x2DA|L_SA*^lw##Q(;3zV+;tL3LEg_`J)B zPbZn-&(9?{=ai@K&OH1VD};SKjIUi6c7J=ZIw^ThY)p}vObJbSa-YAv7Kr@3a4R@G zN45D`MMC`N|uwsODEeFrxL>J7vlcWdvZRj3?y z`v+0D^lCCl!1fE*x-KbwR;<+9x}}ZYa84sUgH8okr$r`u%LnU*FU?J6&SKjcZc z`jWCJ`|On2B!`lu+7}B*!S~XILq3V*j3b>Xiu(x(A-cX2#A;ItMqweTi4!FkR-E30 zr_(+zrWs`lRtD&E8oP>zU+7~Gb>({z}?~JLJZLLYrH%ye0)Sc z=ZjTWnq@Y8a>mjWx*3%8!UR4s@nWeua5PqQ_j6x)Q^Nv*o~YM~($gH5EyTN4D>W1N z1g$Yn#}mBN1@T=Drf=tDSW2PU1n)DnRy!8ayT5k z`VJ|2UEj>+iAD)enO@Idf19WKG4SKUezASea!`Nk28hf#Sa)M|T(YoF!%7u`X^G2hbKc!~=<{iI$0`dwJF{*zmF1OBd&N46@qiob2;yjMQ)OoL!a<*d03Gf8z06U+I^!@ZcJ*9fUmjZ?-8Xtt z{Wr;;8G$AEW%+K~5urKFB^TRx44~{=Eoj3IvOs;J7iDE(FI4tJw%B1$oLa8lO!+63 zML7Qk7pEcz?R3H#!n3Dtqm0ivc)~dZ;bcz8FhH40)H!Lr`z|h`|J5YWy6P?7HpD}z zcNjN-_B%66AluM*Hc?C1GX$4Jkwmk+u9yB!b42`Vi1}0J;&6j^$|ljydYTh~A`Y^R zF?xfQuj;W1KMHu+sq4e?KWe@8(TGs$=_;w(kzCZZv5SCw+sg8aA?~kNCYw#K@u0zc z1#bS30o{$$6&}WTWgqWo*7BhaWJ@OOO^Z+x;-edN>XXM3>7m3b;&?-%;GFnY7&|Df z@|i^!e{hgSpqTwxNYl#uU}MdME3fbI&T1LU#t@UO(C%ZRBJf!Z*?Lmw||p zP*d&I=w<;7M-wJ+RtYuY)EHP>`}2LvBMtYH2jFNB;ZesYMtM~}4teHwEE9Kp_gxZ1ND`KO)P7+L z7vqp*WZV>`##4v(U?4AFQjxVa(NhycCV$!lVOcsls;td!i|g??A4YYwG+XpP!h^kk7N=O2K_fBq{9^6S0_O z(=ew6bw_4^fF6qCn4nHEuIy-sXl=4m@wb+lXv>mL&+zFD3m>XsfHZXy7&TjjEP{YK zhL0b!p;EOUL+0(#MVXPXO?ZTK)t4ketaeRh63t*^tJ>XxzI61T^vWj@7Hht>1&J9t zl+_)ns4Ls(GppE&fXfl|XEB3#@6nm+b{nGfE2ztAoHu+H*6yUL>oXh>JWY6#);>fpdH zoshXcpQ|URHU@A3{$^9XsS}@H~15=N0OQ@&>6;4d%2%r<_R$Y#DBF8PT^U067J{> zy)=?9FMoW?mYut2koLH#$v5oun+5s_zvatyIVsKTVD4Y{e_Euy<$015Wb~j}QG8*L zJA|^0i~P&CbxKByEeiG7dU^(QS4l>J`I?!pk+I~KLN@u-JO;(;UDm5Ex}?;p(m#?2 zWWSoQpu=3S%vgs&UcowYJheYXLqm&7=-obyNaw~`(48h626;TiGopL+CXJLoWSaZo zKL4WxY|JF90J(-Z46n3(tkKsxd`6rGSf%D)KE6n*lJX<)K?th<6evJ{`{c zs6%K+h2No@RUb_XijR46?D2HV3=InjpfUu^Ug)v;`A22>fQ1_HdmayH!*tDMf1rs- zDbvhqPZ z;C#Ivg$%Ok=biW&X7)UYfHX3)5LL)=67W-4)M5@0M&P~DB_+7bL-wI#xmUQb;XW6v z!eZ)a*>JJ|v+nPwF&NJ1p6APAGcO;P&5ZWoTw{d3iOvLSPfIXSA*JGEpQVi3>2@mG z6NgbmDW7h#c6}LCmE5i)eg?=n-Nyt)=L4RobJytDe(%Jgp(lK*0Qz`mwJEN}w14;OTc~4HDMJ8%h`h+Z@0W}(wp6#R* zeoLiQ_m@3*CwcNe&0A3P7h{XRXi!|?r6nuAXxjBj00)MK=$cuAG<5rkD?D)}Rg>x6 zqLn+X(x`Dt3UM%qqbB<0${d+v%(v{sYMsZ;?1V8skCHPLV#8~X_5*S*9)6_sCPM$M z`BpBwS#w}HxGU%<+KhB$zogJtqw)$OL;Z*soITvyudR#qm%{6CGB70E=T`^I&< z9!c4aanEuT8OS2vnh{#b*P!u7J!T1##$~k0rovOIj;2FU&DN^doZxgt8C{q%B7qaCnv zfCHzjO&GB@qTZ(rh?;zC9~iyxwZrq%@Xd5En|hkK?TMmF@`&;ShIeHYG^)I^wIm}| zGD-qo9Ay`Xo7nPhw0nwxQ+2ixPXnr1Vx2$%>c`SV7eb=HisEZ(N=3Y-&K!y7OU1qq zKTz`~cQRplh%tK;A%y8m5BVbZR2Js+Iq8di zcnxgQnu>b;i9W+Dv)fHz*_Q%!1Bqfdkm=~5X-=NK_O@=Y%=44o7etNwA7Wx$zxmqi zO;e^9e~QnS?fv1HOgvTb zH1KJs>vg~Q8~PXBEksH_52-y=O=n@rGMgjI<{7mN@4o&jp$i4ut#FS8Z7{u%#Ldu9 zdfNv37Q8jaJWf}``_7vMp8a~PMMGK1C-bDE)Uo>`m+~&*r>T6K6LHXq_A~q-XAE{pyu+PS)nb`ynW<_@MaHbDCL%)m(Bb5hd!B7r zJfll=7;_XQOP0e!6|)TtwklY^g-}hj45(v^5?`8aZ&GjzE{d;VF){zk6Q754LG{|d zB2&HM#N(&4#L;3F_vxIeoxj(u#KXN7y4%xm_X-X7s@Q1Bkto;~>&uC;1#5+-@~Rh? z8S)vz#BG`eeW78qn`~tQU37z8jh)AjxIRl65_9`$oi%GWntmd@v-*}qai*1L&L#4Q)iV)IJkTR- zGfeKYx>zk@GxIbuzm$pX>&92c`^Ir+@!QpXj+s&Tm!6j6-wHM&^1n(~#rzPoWR_vh zW{PEdFMobh+K02jIcU?+n|`{+{cxl92XpxtwJZ^?UdRJ9-uKgzkI7a(+7zTJj`_8B zNGzYpx%8~f0vNl+*db3u{Prcz7RvNfDclp=v2#~D>mgyR6#IDdoHMj zqdA<*!`=yX3IqU%Nq9IxVYYBrdULoH!U4>%*VM{DkFWqU=nAL-)tqGD)(Ax}7r2&} zx;D(q7A9iBAR&$;<^e(h*u!0+^d9zh4oHv(nBfmD2z7r~%*{amN5s_@%%GybR(v^kOa+mLN@8`M*J+p1=&&uC7iXZfEH_W;B-JT-a-6@Aqz*sTo6vK2uBC{J4~p#<4adC0|Tm_{_pnL zJE^Jt1Kt7oHx^KQaC<MfiDnfV@2Xmb|>?{{o@mf>v)2NaGO{6yfFL6XfUT1M&lfdH*T&0`7uD1>7Ab z50H!RuNn&&NFIdWc5<-#)8wvOKqzNW#6s`l6ove!9OVm0#sv;_b#&2o zbhHCA+}TQh2l1gTd4t0S`S)q7DafJ%cKU~qX{^>!sf0uT*hTnA$iZD(d9?t)nFz&xO z%zc+L{_e3D_y5F+*dKv^NiwK*f0dz<7b+KW|05axjWd+J|1Yn<^~L{774-D~Rq`M4 z`(L{LOV@wIz<(tC-{|@;UH=gS|B>*2qwD`Ox^Vuvoq{`{RzdEl&5~CuDI02|b>Cb? zK^C9^Z~`0+w6RyCO0b<2^^pJoF7e$54UnEmfhxpuRZ^3~TE`_P0dVBd+bW=nXk6v= zTxA^X?^fl2KZ`}U1-(1M)tX-08cu(=VBE7{c0kDyE6GY}d(7@G_$L{`p|`(>kbC_* zdkc1c=shffdJ(b@^d1FErv^4x>q?d$C&gSd9RMY zkUW=AjYR7qN`<_WVr$BtjgZJ-2BJ-@LNJOUaa`-SoOlv8!mK}LBP#`t9-}=!@AEvut@#eAzT3B0utC~!YkRTQ%13<9_n0Dd}T1;{)H&jG8u(WNvb5nEI>S}9y zC}4~xMmbbRO91AJ^0C=Dh z(K|d0$*6tNve#!o1uCT4;;}7@=7}UWq=fM%;@#|QZBag9%8R`>8p*djS!QUpK9FI> zbWV88PI}k?81G#qq0Fb%vz?2w&h=Hw-(1QdS=_d`_rxY-MK0^3f10!V3t|FKeWk7K zZKTye`VWz>7RQ8)F-;XzrPu$I z6)h&b!|8!CX<`ZbYi#M_)7+$mC=!tP-lF%O4hI<{6Iuu}|J7s%g+EROyd%&nWxKR` zn0E9>-y16DGd%0F=4XIhntq!1|5yF{zi%9{1=N3yC&%lXpP!#Z2LKRarR|gu?P);R zwIJ1#nqdHdHXBp2C{X9(nu?c|Fa^NR5Y8Y;Dy><*RAU-N2^15vBZ~ZbCe72O$uPoD zfR1wJ1%zFYKaF?LcC;>B?)hh#aQw8C6tW=AWNNV2IED-{GrG1y^c_ZG524vZXi;5% z8ee#>w%nxVjwENU6?U@S&*0z>!BQoouw=-67z`Gct1aXGm;)=<=BK`N=iC{!6hgBO z=ks8Sa7E^MOy~2@vJ6t5gh_x(@>pf1Q}#4TMo0d|#K&YQSCXk!fe=`qQO?XV08kX& z;S|B1v>|$A*~?D=Km|^5Q(V$Bpa|&$)$`#G7=To=E{?oWXh|yCLMA2_pjiKiBQHU! zBo(03;|YKC6#xif9*><84&p2>?jy zwMXMVN4@To0+1#Gz0L@|e^g=8})W$|($+8nOu>6+@v(50Hx38)O2#n-6o$Kz|(Pwjcq^Ze$LeO4^6`+j=@PN_F@g~Ac* zU31Qdq!)&4RFB$;DLH`+n?2arYHg6DWNFv(UUd3ReVe|E( zMoq93D{m1EP^|qG-1Xo8jL5Yr|#wtHdOtF>eInZibr?Rd^@q{c5XoU2kY_tzl zAEyPZ!LR#6Sm1DG!%!NkfJ%%cq+{*Zm?&o9yzDZ)s&>n)FuI4TX~Sz46Q`=yy`}DL zCM*)$BGN<ysIp`0K#Ey2z{9Qe63rN=U_K;;T$h+83tK98ElJ zcR3MHm<{G+S|tsk;X5=o)1hkJ?{Qz5Cir#MdhQPHNgd@(`R_ z!q9eusty3KW27cTS?E`rnYQ&1mj^3{sn933Vb(Cg2rPW+Z%16rV_N$=PjW5c$6PZz z8#X-jKlH7TS())*(wbiy$8o+qXwSSAxTb~yUT-N8GzAYJZC#@UR0qr1Fek@R_EV22 zqt);O%);eMl|*m#vf7j5gji+D1pc>)_h2W)C~?6m5g)->>$Lhj-cc;wJ}f&i1P>n`xx2ZoH@d&rztQIpk@Q4Y&Lie2 z@=h%qj!nw;Sc#O?)qS&i*%EI->-95lMD*9E{9!o}`@q%_L4J?W`@PL?9`ESmoUlGt z6Ym$?RL!QAdZr8J;xF$}u5NB_K1|`zPl)5^*! zFqfsQW;466iXo^UyMD>9Nx#|aO|d-c$R) ztS9+wi}eme+2ATnT(Yk;-8>-ArZ-A${m#^5i;E5~%8h3Dd3lMvw@Tj0b2aVoI^x*l zAK#ap5mIe4DeN~MU8QVYe9mw!%-4yYm|^t_uGV(??X#nn8P4Fd6jc^0ecQRxTD8g9 z)Y{4K=t(ip>0}1`r9*p#noWMB&r@r0@Eso?hi2gkZN@E>)i2t}%gdWj&U%jz%#aA?ApTb~Ru}76^ws<6Wwo4vB_g&sREERU2mWOu zMJY$OETb?ABiphX&qGVC&Akle!k<;F5c!Udj`bO<9Dylg_pHcD+WXz3KnHBe-+7q~ zk|b2`C4Kokx3aS=n*~G`883%vz4L0d=+spi85s}6xRJ$O%9`HZO=V^@B*$o|rC%*| zDh_6*%fwQ8D>H@^V)VF<7pBDS;=y0K_?#O+63n9#!IErcpESA}tvt(WV2d;!igePx z44etUSXbuebHl$|UABHNNjjycn9zaniUbi!kxLG&jG_S;`o5+6%w?FFy;oE;rxyaW z69uG`@v0+6Rn!YgdQaI2Gw){PaU%%M{p3oih3C<_3_!G0!7dK82!_lx$`2$u6{FD) z6hraZco%U|6IyXAo_BeNBe7R9!{WC&5ZBP>Hg04J8x)6?8@~gscrDCWpXv;;a2s`y z=_;6~^_8Ek*uZumh0{>@A+{VtLujNjyIGIs1wCP+XinGO4EGs#$f%>~59g1xc5e z>^+qTm8QsJZO>&=%F4=`q=3cnxUF`@Z0+vqte+OkC{JH)iLt`57`QDCkg6}1Fs zt8-j(K&8(oz1UhNzXJ>^ym#>KMR*x1G~H__vMI+O1)>!nosfpS7HDpjqRFL zvFAXBvXTt^&%Xlz#ToXH7Bhze|qjEs!kms71n4Zkiel&6WY44zgQK6i_%V*5s^0`ul=0||#S=f6BB;Dn#hcwd#gU%}n z;?v&!(U>Tzv&E(iyjzrU+dqF6m@&S%$WtanNkcPn?{w)Mx8HY%C6&ThuWa|=0y@pF zfZk$CunKgJHe=OsY&He%`_7z;oL-vf;FyCjrFR1a>u>CgdXqZj_iHbcv_kY9hvP+W zANMw_-gkPb#Xh5Ia*=&=iPZ-1k~W3C<iK)cuxB0^DM1|-Zlar%X{51GpWvnEn>Djc!mGttAl+Ft98W7~6&7 zgq4{Wncvecchc?*2=|&n%YC5C+x>E301S@W0G|ywiVO@4kY>%GlDtFX@B99JDFfX; zL!!E?Q0E4#`1j6`<6~ld~dtlzk-a*V6CD2k}U<}PQt*oZo^a8ceyAdD*Ho&c3A^*QGU7jrZ~K&AGxe%+Rj>mN~@UY+aUorR{ShfV~4Q*M2`cYD)QxO6_*p>sb~<$Y`*JntuBm(PTI$|b5QEfC%AJ`wi~gSj;r+m0D6vzXl?fMZ^$8seFcTry1RT# ziAvWizq`RhhqTbhKh_H@X|N;?GD=)QC&a(3O5B#*$HFpF+Sa3vNbN}nn8`;y#~3>} z)Z;jr*KPUi_CvJ7_sy#Ch}EEf>uF!hc4HHG$UC|-kn({>f(6?vkda5&XWU0A>`ckZ zzD4z?g^o98RSGXVlXc}X#{EvT?7jT*88`V7#8U3Re-w=aR&aVxQ2!i55`jl|fTZp| zhwJK2^@g`z-m7o&c4OiLyX~a<-5O7MV4dtOtzX_KE3uJbzMr>DWoRe-jxBlZu+J8R zIP_ieza7a}(8{^Um}8uKrr(^4@hsb=T%02GnlLY zP=C4=A5U1;c&3IL4&-|chTAPC0ZhKqqroH+?r zka+$3gh0eD`QAwD^|pk{=o{v1(#}}Q2P&b`iY=9V6F}`^a`w{jXG@>a0xC%Y`IvoG zNB2}NstTHi9DN)n#r+xSe{Y1;$NJvU^(`KvMI*E85H~EL41P#_~{+3A&ek-nf!* z5?vWEX#Neg2Q@0}8uyJ0I2NA#y2|#ED54{CKfMTl2KsI3J7l zlj%K$*S*f>>8)ot4OL`#v@(DnA-|c9-gP=j!dp5;d-*hr|v)x*fMLEuF%n^9Mzqee^iTbIDAU z>N}Nx>9Lmx+V9o)tbLIBZ1Y)yI0GV1?%pf``Y6eQ5+Q(iUS5xV0h4#IquOt1+lq74 z_}P;0O60rPqpj83LvSZC4d^n)-QsP`$?=V%FP2~7nssX_=XfktX9j2-e2dPhcO@v| zz_9VmSE3}i$-n5jiMA@iO@F&pcXW({f!_?mK%e|51*cv`GML|HRkwx!PsOOM$wRj{ zHGK7VY|+~Eh>}Kmdb74;8ZwMl;MUMtnEgT_tke;Q(`p+3qUU43i}(zTQTsR^_4%mK1tZw=8(6ZjkW@f?Q2|GfGi3* z{tE)~2_|0ORRrJjT`lO<3<{qHt0T8dcpe}6Dp}P`0|2bA=u7~$_jXfk zxY=H(Ox8KrFP_Y=zH0-o6FLQwRD+K@^8^iZf<7iD2h&rf z$4m5xXm)%60Ez&Cn0*;6Gbh-#>(^0xgw-nRV>H#&E1jH_RoOQx?yYAzpwI5U z%GK{wX4M3+;_ksx0#xZ&>^>2LR=Ye)2O_yIH{={gw+%PQuEOPhQ={Ic>rQ&roor`= z<9i{nd+2)o_V8%=*T&K4IyYiQgf4nVCA)f!oo41V8dm0RSdNK0V0<-Zeed%v2yQ!~>O1#jnvd z7c^O5IJReYBmMVz{gxuz$yv@>5aCi)w=UZdT+W zQyNW>^*+ZPIUHY{db%2pRU~2Jl9!&D8ir-^>Im1}jr;ZERUaeX+Ym+bvU$*N+Gy!`#+ z278GVo>){sb2HqwIFvFUR!0714g~>d)c4k9AM?8PdI&MCp<^fCb#d{nXpa>E&homL zQ05$OOEF@G~2adY$K(1lu;y!l74GE*thLU!y! zVM-M_Bw6d;)0ZAYiP_QT4W(d39W2zUgI|Y=X(5%mHPu2|bDza&LuI|n^U%Lf-}%Oy z3CX*xw=^|Gd!4B%!X=GTTfP16pmaiHqt!4{_5)MT%Yp{umiu8eG@=gLo8G#=W`5f< zci*R0@|O|70+?M;zmiPgXDQ(ZUdvYJfIQ5aOy)0&)xH`|%z_Nd%4#M?({I04`-9Jd zyt?mCfUQcrQcU>2i@*xX1x=AnKFsFHN-8Zm3j|8_c>jw6W>+#oRZB$rvE5KTvm1Y!7GzrO*Ia=b#(O@;{NRVdh|B=NQsOQ04V$}ND*qx0lTR$ZRXH3`7ldny}P2q z@_BzY>$P?FPe}oZ56S(j3D>3xv{oZ%tjp@QoP_{I-c=a~2VC#i?85f!q}n$s2K1ZK zN{7t8o^r_35b|rYQyFNl(l2~%Fxn~t6`_XrFwFizSI ziaFB@ydB!{e!;UUo>;wjoFMiJwOVY~>^La9ZtJ+_Zr<2gcR(ta>bTR+7r^{%#%pda zv6b&eE@gIdGc){}&td7X|2$!h(rUWq<~YGmW)o2Sv + +# Messages (e.g. shutdown) +msg_color #ced9dc +msg_font Hack Nerd Font:size=18:bold:dpi=75 +msg_x 50% +msg_y 40% +msg_shadow_color #702342 +msg_shadow_xoffset 1 +msg_shadow_yoffset 1 + +# valid values: stretch, tile +background_style stretch +background_color #003E53 + +# Input controls +input_panel_x 50% +input_panel_y 45% +input_name_x 394 +input_name_y 142 +input_pass_x 394 +input_pass_y 178 +input_font Hack Nerd Font:size=12:dpi=75 +input_color #003E53 + +# Username / password request +username_font Hack Nerd Font:size=18:dpi=75 +username_color #ced9dc +username_x 270 +username_y 144 +password_x 270 +password_y 180 +username_shadow_color #003E53 +username_shadow_xoffset 1 +username_shadow_yoffset 1 + +username_msg Username: +password_msg Password: + +# Welcome message +welcome_font Hack Nerd Font:size=28:bold:dpi=75 +welcome_color #37817E +welcome_x 50% +welcome_y 40 +welcome_msg Login to %host +welcome_shadow_xoffset 2 +welcome_shadow_yoffset 2 +welcome_shadow_color #003E53 + +passwd_feedback_x 50% +passwd_feedback_y 80% diff --git a/slim/util.cpp b/slim/util.cpp new file mode 100644 index 0000000..2028058 --- /dev/null +++ b/slim/util.cpp @@ -0,0 +1,70 @@ +/* + * SLiM - Simple Login Manager + * Copyright (C) 2009 Eygene Ryabinkin + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. +*/ + +#include + +#include +#include +#include +#include + +#include "util.h" + +/* + * Adds the given cookie to the specified Xauthority file. + * Returns true on success, false on fault. + */ +bool Util::add_mcookie(const std::string &mcookie, const char *display, + const std::string &xauth_cmd, const std::string &authfile) +{ + FILE *fp; + std::string cmd = xauth_cmd + " -f " + authfile + " -q"; + + fp = popen(cmd.c_str(), "w"); + if (!fp) + return false; + fprintf(fp, "remove %s\n", display); + fprintf(fp, "add %s %s %s\n", display, ".", mcookie.c_str()); + fprintf(fp, "exit\n"); + + pclose(fp); + return true; +} + +/* + * Interface for random number generator. Just now it uses ordinary + * random/srandom routines and serves as a wrapper for them. + */ +void Util::srandom(unsigned long seed) +{ + ::srandom(seed); +} + +long Util::random(void) +{ + return ::random(); +} + +/* + * Makes seed for the srandom() using "random" values obtained from + * getpid(), time(NULL) and others. + */ +long Util::makeseed(void) +{ + struct timespec ts; + long pid = getpid(); + long tm = time(NULL); + + if (clock_gettime(CLOCK_MONOTONIC, &ts) != 0) { + ts.tv_sec = ts.tv_nsec = 0; + } + + return pid + tm + (ts.tv_sec ^ ts.tv_nsec); +} diff --git a/slim/util.h b/slim/util.h new file mode 100644 index 0000000..4e28a40 --- /dev/null +++ b/slim/util.h @@ -0,0 +1,25 @@ +/* SLiM - Simple Login Manager + Copyright (C) 2009 Eygene Ryabinkin + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. +*/ +#ifndef _UTIL_H__ +#define _UTIL_H__ + +#include + +namespace Util +{ + bool add_mcookie(const std::string &mcookie, const char *display, + const std::string &xauth_cmd, const std::string &authfile); + + void srandom(unsigned long seed); + long random(void); + + long makeseed(void); +} + +#endif /* _UTIL_H__ */ diff --git a/slim/xinitrc.sample b/slim/xinitrc.sample new file mode 100644 index 0000000..8ac5a7f --- /dev/null +++ b/slim/xinitrc.sample @@ -0,0 +1,23 @@ +# the following variable defines the session which is started if the user +# doesn't explicitly select a session +DEFAULT_SESSION=twm + +case $1 in +xfce4) + exec startxfce4 + ;; +icewm) + icewmbg & + icewmtray & + exec icewm + ;; +wmaker) + exec wmaker + ;; +blackbox) + exec blackbox + ;; +*) + exec $DEFAULT_SESSION + ;; +esac