diff --git a/.liborc.metadata b/.liborc.metadata new file mode 100644 index 0000000..dadf4d6 --- /dev/null +++ b/.liborc.metadata @@ -0,0 +1 @@ +0ce492c1a98996fe023eed816543f374f56607a7 SOURCES/orc-1.6.6.tar.gz diff --git a/SOURCES/0001-cmake.patch b/SOURCES/0001-cmake.patch new file mode 100644 index 0000000..a6ad094 --- /dev/null +++ b/SOURCES/0001-cmake.patch @@ -0,0 +1,351 @@ +--- orc-rel-release-1.6.6/c++/src/orcConfig.cmake.orig 2021-09-02 08:12:02.402411800 -0400 ++++ orc-rel-release-1.6.6/c++/src/orcConfig.cmake 2021-09-02 08:11:53.797563660 -0400 +@@ -0,0 +1 @@ ++include("${CMAKE_CURRENT_LIST_DIR}/orcTargets.cmake") +--- orc-rel-release-1.6.6/c++/src/CMakeLists.txt.orig 2020-12-03 15:46:53.000000000 -0500 ++++ orc-rel-release-1.6.6/c++/src/CMakeLists.txt 2021-09-15 14:47:07.195633659 -0400 +@@ -227,7 +227,13 @@ + add_definitions(-DBUILD_LIBHDFSPP) + endif(BUILD_LIBHDFSPP) + +-add_library (orc STATIC ${SOURCE_FILES}) ++add_library (orc SHARED ${SOURCE_FILES}) ++ ++set_target_properties(orc PROPERTIES ++ POSITION_INDEPENDENT_CODE ON ++ VERSION 1.6.6 ++ SOVERSION 1 ++) + + target_link_libraries (orc + protobuf +@@ -238,4 +244,38 @@ + ${LIBHDFSPP_LIBRARIES} + ) + +-install(TARGETS orc DESTINATION lib) ++install(TARGETS orc ++ EXPORT orcExports ++ DESTINATION ${LIB_INSTALL_DIR}) ++ ++include(CMakePackageConfigHelpers) ++write_basic_package_version_file( ++ "${CMAKE_CURRENT_BINARY_DIR}/orcConfigVersion.cmake" ++ VERSION ${orc_VERSION} ++ COMPATIBILITY SameMajorVersion ++ ) ++ ++# A Package Config file that works from the build directory ++export(EXPORT orcExports ++ FILE "${CMAKE_CURRENT_BINARY_DIR}/orcTargets.cmake" ++ NAMESPACE orc:: ++ ) ++configure_file(orcConfig.cmake ++ "${CMAKE_CURRENT_BINARY_DIR}/orcConfig.cmake" ++ COPYONLY ++ ) ++ ++# A Package Config file that works from the installation directory ++set(ConfigPackageLocation ${CMAKE_INSTALL_LIBDIR}/cmake/orc) ++install(EXPORT orcExports ++ FILE orcTargets.cmake ++ NAMESPACE orc:: ++ DESTINATION ${ConfigPackageLocation} ++ ) ++install(FILES ++ orcConfig.cmake ++ "${CMAKE_CURRENT_BINARY_DIR}/orcConfigVersion.cmake" ++ DESTINATION ${ConfigPackageLocation} ++ ) ++ ++ +--- orc-rel-release-1.6.6/cmake_modules/ThirdpartyToolchain.cmake.orig 2020-12-03 15:46:53.000000000 -0500 ++++ orc-rel-release-1.6.6/cmake_modules/ThirdpartyToolchain.cmake 2021-09-15 14:21:07.299584448 -0400 +@@ -79,8 +79,8 @@ + endif () + + include_directories (SYSTEM ${SNAPPY_INCLUDE_DIR}) +-add_library (snappy STATIC IMPORTED) +-set_target_properties (snappy PROPERTIES IMPORTED_LOCATION ${SNAPPY_STATIC_LIB}) ++add_library (snappy SHARED IMPORTED) ++set_target_properties (snappy PROPERTIES IMPORTED_LOCATION ${SNAPPY_SHARED_LIB}) + + if (SNAPPY_VENDORED) + add_dependencies (snappy snappy_ep) +@@ -121,8 +121,8 @@ + endif () + + include_directories (SYSTEM ${ZLIB_INCLUDE_DIR}) +-add_library (zlib STATIC IMPORTED) +-set_target_properties (zlib PROPERTIES IMPORTED_LOCATION ${ZLIB_STATIC_LIB}) ++add_library (zlib SHARED IMPORTED) ++set_target_properties (zlib PROPERTIES IMPORTED_LOCATION ${ZLIB_SHARED_LIB}) + + if (ZLIB_VENDORED) + add_dependencies (zlib zlib_ep) +@@ -170,8 +170,8 @@ + endif () + + include_directories (SYSTEM ${ZSTD_INCLUDE_DIR}) +-add_library (zstd STATIC IMPORTED) +-set_target_properties (zstd PROPERTIES IMPORTED_LOCATION ${ZSTD_STATIC_LIB}) ++add_library (zstd SHARED IMPORTED) ++set_target_properties (zstd PROPERTIES IMPORTED_LOCATION ${ZSTD_SHARED_LIB}) + + if (ZSTD_VENDORED) + add_dependencies (zstd zstd_ep) +@@ -212,8 +212,8 @@ + endif () + + include_directories (SYSTEM ${LZ4_INCLUDE_DIR}) +-add_library (lz4 STATIC IMPORTED) +-set_target_properties (lz4 PROPERTIES IMPORTED_LOCATION ${LZ4_STATIC_LIB}) ++add_library (lz4 SHARED IMPORTED) ++set_target_properties (lz4 PROPERTIES IMPORTED_LOCATION ${LZ4_SHARED_LIB}) + + if (LZ4_VENDORED) + add_dependencies (lz4 lz4_ep) +@@ -327,11 +327,11 @@ + + include_directories (SYSTEM ${PROTOBUF_INCLUDE_DIR}) + +-add_library (protobuf STATIC IMPORTED) +-set_target_properties (protobuf PROPERTIES IMPORTED_LOCATION ${PROTOBUF_STATIC_LIB}) ++add_library (protobuf SHARED IMPORTED) ++set_target_properties (protobuf PROPERTIES IMPORTED_LOCATION ${PROTOBUF_SHARED_LIB}) + +-add_library (protoc STATIC IMPORTED) +-set_target_properties (protoc PROPERTIES IMPORTED_LOCATION ${PROTOC_STATIC_LIB}) ++add_library (protoc SHARED IMPORTED) ++set_target_properties (protoc PROPERTIES IMPORTED_LOCATION ${PROTOC_SHARED_LIB}) + + if (PROTOBUF_VENDORED) + add_dependencies (protoc protobuf_ep) +--- orc-rel-release-1.6.6/cmake_modules/FindZSTD.cmake.orig 2020-12-03 15:46:53.000000000 -0500 ++++ orc-rel-release-1.6.6/cmake_modules/FindZSTD.cmake 2021-09-15 14:10:51.272792107 -0400 +@@ -14,7 +14,7 @@ + + # ZSTD_INCLUDE_DIR: directory containing headers + # ZSTD_LIBS: directory containing zstd libraries +-# ZSTD_STATIC_LIB: path to libzstd.a ++# ZSTD_SHARED_LIB: path to libzstd.a + # ZSTD_FOUND: whether zstd has been found + + if( NOT "${ZSTD_HOME}" STREQUAL "") +@@ -23,16 +23,16 @@ + + message (STATUS "ZSTD_HOME: ${ZSTD_HOME}") + +-if (NOT ZSTD_STATIC_LIB_NAME) +- set (ZSTD_STATIC_LIB_NAME ${CMAKE_STATIC_LIBRARY_PREFIX}zstd) +-endif() +- + find_path (ZSTD_INCLUDE_DIR zstd.h HINTS + ${_zstd_path} + NO_DEFAULT_PATH + PATH_SUFFIXES "include") + +-find_library (ZSTD_LIBRARIES NAMES ${ZSTD_STATIC_LIB_NAME} HINTS ++if (NOT ZSTD_SHARED_LIB_NAME) ++ set (ZSTD_SHARED_LIB_NAME zstd) ++endif() ++ ++find_library (ZSTD_LIBRARIES NAMES ${ZSTD_SHARED_LIB_NAME} HINTS + ${_zstd_path} + PATH_SUFFIXES "lib") + +@@ -41,14 +41,14 @@ + get_filename_component (ZSTD_LIBS ${ZSTD_LIBRARIES} PATH) + set (ZSTD_HEADER_NAME zstd.h) + set (ZSTD_HEADER ${ZSTD_INCLUDE_DIR}/${ZSTD_HEADER_NAME}) +- set (ZSTD_STATIC_LIB ${ZSTD_LIBS}/${ZSTD_STATIC_LIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX}) ++ set (ZSTD_SHARED_LIB ${ZSTD_LIBS}/${CMAKE_SHARED_LIBRARY_PREFIX}${ZSTD_SHARED_LIB_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}) + else () + set (ZSTD_FOUND FALSE) + endif () + + if (ZSTD_FOUND) + message (STATUS "Found the zstd header: ${ZSTD_HEADER}") +- message (STATUS "Found the zstd library: ${ZSTD_STATIC_LIB}") ++ message (STATUS "Found the zstd library: ${ZSTD_SHARED_LIB}") + else() + if (_ZSTD_path) + set (ZSTD_ERR_MSG "Could not find zstd. Looked in ${_zstd_path}.") +@@ -65,7 +65,7 @@ + + mark_as_advanced ( + ZSTD_INCLUDE_DIR +- ZSTD_STATIC_LIB ++ ZSTD_SHARED_LIB + ZSTD_LIBS + ZSTD_LIBRARIES + ) +--- orc-rel-release-1.6.6/cmake_modules/FindSnappy.cmake.orig 2020-12-03 15:46:53.000000000 -0500 ++++ orc-rel-release-1.6.6/cmake_modules/FindSnappy.cmake 2021-09-15 13:50:06.714446184 -0400 +@@ -14,7 +14,7 @@ + + # SNAPPY_INCLUDE_DIR: directory containing headers + # SNAPPY_LIBS: directory containing snappy libraries +-# SNAPPY_STATIC_LIB: path to libsnappy.a ++# SNAPPY_SHARED_LIB: path to libsnappy.a + # SNAPPY_FOUND: whether snappy has been found + + if( NOT "${SNAPPY_HOME}" STREQUAL "") +@@ -38,14 +38,14 @@ + set (SNAPPY_HEADER_NAME snappy.h) + set (SNAPPY_HEADER ${SNAPPY_INCLUDE_DIR}/${SNAPPY_HEADER_NAME}) + set (SNAPPY_LIB_NAME snappy) +- set (SNAPPY_STATIC_LIB ${SNAPPY_LIBS}/${CMAKE_STATIC_LIBRARY_PREFIX}${SNAPPY_LIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX}) ++ set (SNAPPY_SHARED_LIB ${SNAPPY_LIBS}/${CMAKE_SHARED_LIBRARY_PREFIX}${SNAPPY_LIB_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}) + else () + set (SNAPPY_FOUND FALSE) + endif () + + if (SNAPPY_FOUND) + message (STATUS "Found the Snappy header: ${SNAPPY_HEADER}") +- message (STATUS "Found the Snappy library: ${SNAPPY_STATIC_LIB}") ++ message (STATUS "Found the Snappy library: ${SNAPPY_SHARED_LIB}") + else() + if (_snappy_path) + set (SNAPPY_ERR_MSG "Could not find Snappy. Looked in ${_snappy_path}.") +@@ -62,7 +62,7 @@ + + mark_as_advanced ( + SNAPPY_INCLUDE_DIR +- SNAPPY_STATIC_LIB ++ SNAPPY_SHARED_LIB + SNAPPY_LIBS + SNAPPY_LIBRARIES + ) +--- orc-rel-release-1.6.6/cmake_modules/FindLZ4.cmake.orig 2021-09-15 13:52:14.544322930 -0400 ++++ orc-rel-release-1.6.6/cmake_modules/FindLZ4.cmake 2021-09-15 13:52:31.791036461 -0400 +@@ -14,7 +14,7 @@ + + # LZ4_INCLUDE_DIR: directory containing headers + # LZ4_LIBS: directory containing LZ4 libraries +-# LZ4_STATIC_LIB: path to lz4.a ++# LZ4_SHARED_LIB: path to lz4.a + # LZ4_FOUND: whether LZ4 has been found + + if( NOT "${LZ4_HOME}" STREQUAL "") +@@ -38,14 +38,14 @@ + set (LZ4_HEADER_NAME lz4.h) + set (LZ4_HEADER ${LZ4_INCLUDE_DIR}/${LZ4_HEADER_NAME}) + set (LZ4_LIB_NAME lz4) +- set (LZ4_STATIC_LIB ${LZ4_LIBS}/${CMAKE_STATIC_LIBRARY_PREFIX}${LZ4_LIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX}) ++ set (LZ4_SHARED_LIB ${LZ4_LIBS}/${CMAKE_SHARED_LIBRARY_PREFIX}${LZ4_LIB_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}) + else () + set (LZ4_FOUND FALSE) + endif () + + if (LZ4_FOUND) + message (STATUS "Found the LZ4 header: ${LZ4_HEADER}") +- message (STATUS "Found the LZ4 library: ${LZ4_STATIC_LIB}") ++ message (STATUS "Found the LZ4 library: ${LZ4_SHARED_LIB}") + else() + if (_lz4_path) + set (LZ4_ERR_MSG "Could not find LZ4. Looked in ${_lz4_path}.") +@@ -62,7 +62,7 @@ + + mark_as_advanced ( + LZ4_INCLUDE_DIR +- LZ4_STATIC_LIB ++ LZ4_SHARED_LIB + LZ4_LIBS + LZ4_LIBRARIES + ) +--- orc-rel-release-1.6.6/cmake_modules/FindProtobuf.cmake.orig 2021-09-15 14:15:19.726344469 -0400 ++++ orc-rel-release-1.6.6/cmake_modules/FindProtobuf.cmake 2021-09-15 14:16:22.330307272 -0400 +@@ -15,8 +15,8 @@ + # PROTOBUF_FOUND is set if Protobuf is found + # PROTOBUF_INCLUDE_DIR: directory containing headers + # PROTOBUF_LIBS: directory containing Protobuf libraries +-# PROTOBUF_STATIC_LIB: location of protobuf.a +-# PROTOC_STATIC_LIB: location of protoc.a ++# PROTOBUF_SHARED_LIB: location of protobuf.a ++# PROTOC_SHARED_LIB: location of protoc.a + # PROTOBUF_EXECUTABLE: location of protoc + + +@@ -54,16 +54,16 @@ + get_filename_component (PROTOBUF_LIBS ${PROTOBUF_LIBRARY} PATH) + set (PROTOBUF_LIB_NAME protobuf) + set (PROTOC_LIB_NAME protoc) +- set (PROTOBUF_STATIC_LIB ${PROTOBUF_LIBS}/${CMAKE_STATIC_LIBRARY_PREFIX}${PROTOBUF_LIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX}) +- set (PROTOC_STATIC_LIB ${PROTOBUF_LIBS}/${CMAKE_STATIC_LIBRARY_PREFIX}${PROTOC_LIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX}) ++ set (PROTOBUF_SHARED_LIB ${PROTOBUF_LIBS}/${CMAKE_SHARED_LIBRARY_PREFIX}${PROTOBUF_LIB_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}) ++ set (PROTOC_SHARED_LIB ${PROTOBUF_LIBS}/${CMAKE_SHARED_LIBRARY_PREFIX}${PROTOC_LIB_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}) + else () + set (PROTOBUF_FOUND FALSE) + endif () + + if (PROTOBUF_FOUND) + message (STATUS "Found the Protobuf headers: ${PROTOBUF_INCLUDE_DIR}") +- message (STATUS "Found the Protobuf library: ${PROTOBUF_STATIC_LIB}") +- message (STATUS "Found the Protoc library: ${PROTOC_STATIC_LIB}") ++ message (STATUS "Found the Protobuf library: ${PROTOBUF_SHARED_LIB}") ++ message (STATUS "Found the Protoc library: ${PROTOC_SHARED_LIB}") + message (STATUS "Found the Protoc executable: ${PROTOBUF_EXECUTABLE}") + else() + if (_protobuf_path) +@@ -82,6 +82,6 @@ + mark_as_advanced ( + PROTOBUF_INCLUDE_DIR + PROTOBUF_LIBS +- PROTOBUF_STATIC_LIB +- PROTOC_STATIC_LIB ++ PROTOBUF_SHARED_LIB ++ PROTOC_SHARED_LIB + ) +--- orc-rel-release-1.6.6/cmake_modules/FindZLIB.cmake.orig 2021-09-15 14:20:04.485626684 -0400 ++++ orc-rel-release-1.6.6/cmake_modules/FindZLIB.cmake 2021-09-15 14:20:33.448146843 -0400 +@@ -14,7 +14,7 @@ + + # ZLIB_INCLUDE_DIR: directory containing headers + # ZLIB_LIBS: directory containing ZLIB libraries +-# ZLIB_STATIC_LIB: path to zlib.a ++# ZLIB_SHARED_LIB: path to zlib.a + # ZLIB_FOUND: whether ZLIB has been found + + if( NOT "${ZLIB_HOME}" STREQUAL "") +@@ -28,11 +28,11 @@ + NO_DEFAULT_PATH + PATH_SUFFIXES "include") + +-if (NOT ZLIB_STATIC_LIB_NAME) +- set (ZLIB_STATIC_LIB_NAME z) ++if (NOT ZLIB_SHARED_LIB_NAME) ++ set (ZLIB_SHARED_LIB_NAME z) + endif() + +-find_library (ZLIB_LIBRARIES NAMES ${ZLIB_STATIC_LIB_NAME} HINTS ++find_library (ZLIB_LIBRARIES NAMES ${ZLIB_SHARED_LIB_NAME} HINTS + ${_zlib_path} + PATH_SUFFIXES "lib") + +@@ -41,14 +41,14 @@ + get_filename_component (ZLIB_LIBS ${ZLIB_LIBRARIES} PATH ) + set (ZLIB_HEADER_NAME zlib.h) + set (ZLIB_HEADER ${ZLIB_INCLUDE_DIR}/${ZLIB_HEADER_NAME}) +- set (ZLIB_STATIC_LIB ${ZLIB_LIBS}/${CMAKE_STATIC_LIBRARY_PREFIX}${ZLIB_STATIC_LIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX}) ++ set (ZLIB_SHARED_LIB ${ZLIB_LIBS}/${CMAKE_SHARED_LIBRARY_PREFIX}${ZLIB_SHARED_LIB_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}) + else () + set (ZLIB_FOUND FALSE) + endif () + + if (ZLIB_FOUND) + message (STATUS "Found the ZLIB header: ${ZLIB_HEADER}") +- message (STATUS "Found the ZLIB library: ${ZLIB_STATIC_LIB}") ++ message (STATUS "Found the ZLIB library: ${ZLIB_SHARED_LIB}") + else() + if (_zlib_path) + set (ZLIB_ERR_MSG "Could not find ZLIB. Looked in ${_zlib_path}.") +@@ -65,7 +65,7 @@ + + mark_as_advanced ( + ZLIB_INCLUDE_DIR +- ZLIB_STATIC_LIB ++ ZLIB_SHARED_LIB + ZLIB_LIBS + ZLIB_LIBRARIES + ) diff --git a/SOURCES/0001-cmake_modules-FindZSTD.cmake.patch b/SOURCES/0001-cmake_modules-FindZSTD.cmake.patch new file mode 100644 index 0000000..c249514 --- /dev/null +++ b/SOURCES/0001-cmake_modules-FindZSTD.cmake.patch @@ -0,0 +1,59 @@ +--- orc-rel-release-1.6.6/cmake_modules/FindZSTD.cmake.orig 2020-12-03 15:46:53.000000000 -0500 ++++ orc-rel-release-1.6.6/cmake_modules/FindZSTD.cmake 2021-09-15 14:10:51.272792107 -0400 +@@ -14,7 +14,7 @@ + + # ZSTD_INCLUDE_DIR: directory containing headers + # ZSTD_LIBS: directory containing zstd libraries +-# ZSTD_STATIC_LIB: path to libzstd.a ++# ZSTD_SHARED_LIB: path to libzstd.a + # ZSTD_FOUND: whether zstd has been found + + if( NOT "${ZSTD_HOME}" STREQUAL "") +@@ -23,16 +23,16 @@ + + message (STATUS "ZSTD_HOME: ${ZSTD_HOME}") + +-if (NOT ZSTD_STATIC_LIB_NAME) +- set (ZSTD_STATIC_LIB_NAME ${CMAKE_STATIC_LIBRARY_PREFIX}zstd) +-endif() +- + find_path (ZSTD_INCLUDE_DIR zstd.h HINTS + ${_zstd_path} + NO_DEFAULT_PATH + PATH_SUFFIXES "include") + +-find_library (ZSTD_LIBRARIES NAMES ${ZSTD_STATIC_LIB_NAME} HINTS ++if (NOT ZSTD_SHARED_LIB_NAME) ++ set (ZSTD_SHARED_LIB_NAME zstd) ++endif() ++ ++find_library (ZSTD_LIBRARIES NAMES ${ZSTD_SHARED_LIB_NAME} HINTS + ${_zstd_path} + PATH_SUFFIXES "lib") + +@@ -41,14 +41,14 @@ + get_filename_component (ZSTD_LIBS ${ZSTD_LIBRARIES} PATH) + set (ZSTD_HEADER_NAME zstd.h) + set (ZSTD_HEADER ${ZSTD_INCLUDE_DIR}/${ZSTD_HEADER_NAME}) +- set (ZSTD_STATIC_LIB ${ZSTD_LIBS}/${ZSTD_STATIC_LIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX}) ++ set (ZSTD_SHARED_LIB ${ZSTD_LIBS}/${CMAKE_SHARED_LIBRARY_PREFIX}${ZSTD_SHARED_LIB_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}) + else () + set (ZSTD_FOUND FALSE) + endif () + + if (ZSTD_FOUND) + message (STATUS "Found the zstd header: ${ZSTD_HEADER}") +- message (STATUS "Found the zstd library: ${ZSTD_STATIC_LIB}") ++ message (STATUS "Found the zstd library: ${ZSTD_SHARED_LIB}") + else() + if (_ZSTD_path) + set (ZSTD_ERR_MSG "Could not find zstd. Looked in ${_zstd_path}.") +@@ -65,7 +65,7 @@ + + mark_as_advanced ( + ZSTD_INCLUDE_DIR +- ZSTD_STATIC_LIB ++ ZSTD_SHARED_LIB + ZSTD_LIBS + ZSTD_LIBRARIES + ) diff --git a/SOURCES/0002-c++-src-ColumnPrinter.cc.patch b/SOURCES/0002-c++-src-ColumnPrinter.cc.patch new file mode 100644 index 0000000..2f4bcc5 --- /dev/null +++ b/SOURCES/0002-c++-src-ColumnPrinter.cc.patch @@ -0,0 +1,11 @@ +--- orc-rel-release-1.6.6/c++/src/ColumnPrinter.cc.orig 2021-09-20 09:01:01.284286634 -0400 ++++ orc-rel-release-1.6.6/c++/src/ColumnPrinter.cc 2021-09-20 09:06:30.748470566 -0400 +@@ -631,7 +631,7 @@ + if (hasNulls && !notNull[rowId]) { + writeString(buffer, "null"); + } else { +- const time_t timeValue = data[rowId] * 24 * 60 * 60; ++ const time_t timeValue = static_cast(data[rowId] * 24 * 60 * 60); + struct tm tmValue; + gmtime_r(&timeValue, &tmValue); + char timeBuffer[11]; diff --git a/SOURCES/0002-cmake_modules-ThirdPartyToolchain.cmake.patch b/SOURCES/0002-cmake_modules-ThirdPartyToolchain.cmake.patch new file mode 100644 index 0000000..b04759f --- /dev/null +++ b/SOURCES/0002-cmake_modules-ThirdPartyToolchain.cmake.patch @@ -0,0 +1,62 @@ +--- orc-rel-release-1.6.6/cmake_modules/ThirdpartyToolchain.cmake.orig 2020-12-03 15:46:53.000000000 -0500 ++++ orc-rel-release-1.6.6/cmake_modules/ThirdpartyToolchain.cmake 2021-09-15 14:21:07.299584448 -0400 +@@ -79,8 +79,8 @@ + endif () + + include_directories (SYSTEM ${SNAPPY_INCLUDE_DIR}) +-add_library (snappy STATIC IMPORTED) +-set_target_properties (snappy PROPERTIES IMPORTED_LOCATION ${SNAPPY_STATIC_LIB}) ++add_library (snappy SHARED IMPORTED) ++set_target_properties (snappy PROPERTIES IMPORTED_LOCATION ${SNAPPY_SHARED_LIB}) + + if (SNAPPY_VENDORED) + add_dependencies (snappy snappy_ep) +@@ -121,8 +121,8 @@ + endif () + + include_directories (SYSTEM ${ZLIB_INCLUDE_DIR}) +-add_library (zlib STATIC IMPORTED) +-set_target_properties (zlib PROPERTIES IMPORTED_LOCATION ${ZLIB_STATIC_LIB}) ++add_library (zlib SHARED IMPORTED) ++set_target_properties (zlib PROPERTIES IMPORTED_LOCATION ${ZLIB_SHARED_LIB}) + + if (ZLIB_VENDORED) + add_dependencies (zlib zlib_ep) +@@ -170,8 +170,8 @@ + endif () + + include_directories (SYSTEM ${ZSTD_INCLUDE_DIR}) +-add_library (zstd STATIC IMPORTED) +-set_target_properties (zstd PROPERTIES IMPORTED_LOCATION ${ZSTD_STATIC_LIB}) ++add_library (zstd SHARED IMPORTED) ++set_target_properties (zstd PROPERTIES IMPORTED_LOCATION ${ZSTD_SHARED_LIB}) + + if (ZSTD_VENDORED) + add_dependencies (zstd zstd_ep) +@@ -212,8 +212,8 @@ + endif () + + include_directories (SYSTEM ${LZ4_INCLUDE_DIR}) +-add_library (lz4 STATIC IMPORTED) +-set_target_properties (lz4 PROPERTIES IMPORTED_LOCATION ${LZ4_STATIC_LIB}) ++add_library (lz4 SHARED IMPORTED) ++set_target_properties (lz4 PROPERTIES IMPORTED_LOCATION ${LZ4_SHARED_LIB}) + + if (LZ4_VENDORED) + add_dependencies (lz4 lz4_ep) +@@ -327,11 +327,11 @@ + + include_directories (SYSTEM ${PROTOBUF_INCLUDE_DIR}) + +-add_library (protobuf STATIC IMPORTED) +-set_target_properties (protobuf PROPERTIES IMPORTED_LOCATION ${PROTOBUF_STATIC_LIB}) ++add_library (protobuf SHARED IMPORTED) ++set_target_properties (protobuf PROPERTIES IMPORTED_LOCATION ${PROTOBUF_SHARED_LIB}) + +-add_library (protoc STATIC IMPORTED) +-set_target_properties (protoc PROPERTIES IMPORTED_LOCATION ${PROTOC_STATIC_LIB}) ++add_library (protoc SHARED IMPORTED) ++set_target_properties (protoc PROPERTIES IMPORTED_LOCATION ${PROTOC_SHARED_LIB}) + + if (PROTOBUF_VENDORED) + add_dependencies (protoc protobuf_ep) diff --git a/SOURCES/0002-libhdfspp_ep.patch b/SOURCES/0002-libhdfspp_ep.patch new file mode 100644 index 0000000..dec1c7e --- /dev/null +++ b/SOURCES/0002-libhdfspp_ep.patch @@ -0,0 +1,72 @@ +--- libhdfspp_ep/lib/common/util.h.orig 2021-08-31 10:12:36.331548291 -0400 ++++ libhdfspp_ep/lib/common/util.h 2021-08-31 10:13:17.271857838 -0400 +@@ -49,7 +49,7 @@ + // Determine size of buffer that needs to be allocated in order to serialize msg + // in delimited format + static inline int DelimitedPBMessageSize(const ::google::protobuf::MessageLite *msg) { +- size_t size = msg->ByteSize(); ++ size_t size = msg->ByteSizeLong(); + return ::google::protobuf::io::CodedOutputStream::VarintSize32(size) + size; + } + +--- libhdfspp_ep/lib/rpc/rpc_connection_impl.cc.orig 2021-09-01 09:50:08.587701925 -0400 ++++ libhdfspp_ep/lib/rpc/rpc_connection_impl.cc 2021-09-01 09:50:35.856233304 -0400 +@@ -55,7 +55,7 @@ + + std::for_each( + headers.begin(), headers.end(), [&buf](const pb::MessageLite *v) { +- buf = pbio::CodedOutputStream::WriteVarint32ToArray(v->ByteSize(), buf); ++ buf = pbio::CodedOutputStream::WriteVarint32ToArray(v->ByteSizeLong(), buf); + buf = v->SerializeWithCachedSizesToArray(buf); + }); + +--- libhdfspp_ep/lib/rpc/request.cc.orig 2021-09-01 09:51:25.397381922 -0400 ++++ libhdfspp_ep/lib/rpc/request.cc 2021-09-01 09:51:56.745843185 -0400 +@@ -62,7 +62,7 @@ + + std::for_each( + headers.begin(), headers.end(), [&buf](const pb::MessageLite *v) { +- buf = pbio::CodedOutputStream::WriteVarint32ToArray(v->ByteSize(), buf); ++ buf = pbio::CodedOutputStream::WriteVarint32ToArray(v->ByteSizeLong(), buf); + buf = v->SerializeWithCachedSizesToArray(buf); + }); + +@@ -78,7 +78,7 @@ + pbio::CodedOutputStream os(&ss); + uint8_t *buf = os.GetDirectBufferForNBytesAndAdvance(len); + assert(buf); +- buf = pbio::CodedOutputStream::WriteVarint32ToArray(header->ByteSize(), buf); ++ buf = pbio::CodedOutputStream::WriteVarint32ToArray(header->ByteSizeLong(), buf); + buf = header->SerializeWithCachedSizesToArray(buf); + } + +--- libhdfspp_ep/lib/rpc/cyrus_sasl_engine.cc.orig 2017-08-30 10:56:51.000000000 -0400 ++++ libhdfspp_ep/lib/rpc/cyrus_sasl_engine.cc 2021-09-01 13:55:08.886606370 -0400 +@@ -121,10 +121,10 @@ + // Create an array of callbacks that embed a pointer to this + // so we can call methods of the engine + per_connection_callbacks_ = { +- { SASL_CB_USER, (sasl_callback_ft) & get_name, this}, // userid for authZ +- { SASL_CB_AUTHNAME, (sasl_callback_ft) & get_name, this}, // authid for authT +- { SASL_CB_GETREALM, (sasl_callback_ft) & getrealm, this}, // krb/gssapi realm +- // { SASL_CB_PASS, (sasl_callback_ft)&getsecret, this ++ { SASL_CB_USER, reinterpret_cast(get_name), this}, // userid for authZ ++ { SASL_CB_AUTHNAME, reinterpret_cast(get_name), this}, // authid for authT ++ { SASL_CB_GETREALM, reinterpret_cast(getrealm), this}, // krb/gssapi realm ++ // { SASL_CB_PASS, reinterpret_cast(getsecret), this}, + { SASL_CB_LIST_END, (sasl_callback_ft) NULL, NULL} + }; + } +@@ -420,9 +420,9 @@ + + + const sasl_callback_t per_process_callbacks[] = { +- { SASL_CB_LOG, (sasl_callback_ft) & sasl_my_log, NULL}, +- { SASL_CB_GETOPT, (sasl_callback_ft) & sasl_getopt, NULL}, +- { SASL_CB_GETPATH, (sasl_callback_ft) & get_path, NULL}, // to find th mechanisms ++ { SASL_CB_LOG, reinterpret_cast(sasl_my_log), NULL}, ++ { SASL_CB_GETOPT, reinterpret_cast(sasl_getopt), NULL}, ++ { SASL_CB_GETPATH, reinterpret_cast(get_path), NULL}, // to find th mechanisms + { SASL_CB_LIST_END, (sasl_callback_ft) NULL, NULL} + }; // callbacks_ array + diff --git a/SOURCES/0003-cmake.patch b/SOURCES/0003-cmake.patch new file mode 100644 index 0000000..73c592d --- /dev/null +++ b/SOURCES/0003-cmake.patch @@ -0,0 +1,61 @@ +--- orc-rel-release-1.6.6/c++/src/orcConfig.cmake.orig 2021-09-02 08:12:02.402411800 -0400 ++++ orc-rel-release-1.6.6/c++/src/orcConfig.cmake 2021-09-02 08:11:53.797563660 -0400 +@@ -0,0 +1 @@ ++include("${CMAKE_CURRENT_LIST_DIR}/orcTargets.cmake") +--- orc-rel-release-1.6.6/c++/src/CMakeLists.txt.orig 2020-12-03 15:46:53.000000000 -0500 ++++ orc-rel-release-1.6.6/c++/src/CMakeLists.txt 2021-09-15 14:47:07.195633659 -0400 +@@ -227,7 +227,13 @@ + add_definitions(-DBUILD_LIBHDFSPP) + endif(BUILD_LIBHDFSPP) + +-add_library (orc STATIC ${SOURCE_FILES}) ++add_library (orc SHARED ${SOURCE_FILES}) ++ ++set_target_properties(orc PROPERTIES ++ POSITION_INDEPENDENT_CODE ON ++ VERSION 1.6.6 ++ SOVERSION 1 ++) + + target_link_libraries (orc + protobuf +@@ -238,4 +244,38 @@ + ${LIBHDFSPP_LIBRARIES} + ) + +-install(TARGETS orc DESTINATION lib) ++install(TARGETS orc ++ EXPORT orcExports ++ DESTINATION ${LIB_INSTALL_DIR}) ++ ++include(CMakePackageConfigHelpers) ++write_basic_package_version_file( ++ "${CMAKE_CURRENT_BINARY_DIR}/orcConfigVersion.cmake" ++ VERSION ${orc_VERSION} ++ COMPATIBILITY SameMajorVersion ++ ) ++ ++# A Package Config file that works from the build directory ++export(EXPORT orcExports ++ FILE "${CMAKE_CURRENT_BINARY_DIR}/orcTargets.cmake" ++ NAMESPACE orc:: ++ ) ++configure_file(orcConfig.cmake ++ "${CMAKE_CURRENT_BINARY_DIR}/orcConfig.cmake" ++ COPYONLY ++ ) ++ ++# A Package Config file that works from the installation directory ++set(ConfigPackageLocation ${CMAKE_INSTALL_LIBDIR}/cmake/orc) ++install(EXPORT orcExports ++ FILE orcTargets.cmake ++ NAMESPACE orc:: ++ DESTINATION ${ConfigPackageLocation} ++ ) ++install(FILES ++ orcConfig.cmake ++ "${CMAKE_CURRENT_BINARY_DIR}/orcConfigVersion.cmake" ++ DESTINATION ${ConfigPackageLocation} ++ ) ++ ++ diff --git a/SOURCES/0004-cmake_modules-FindSnappy.cmake.patch b/SOURCES/0004-cmake_modules-FindSnappy.cmake.patch new file mode 100644 index 0000000..c7cefeb --- /dev/null +++ b/SOURCES/0004-cmake_modules-FindSnappy.cmake.patch @@ -0,0 +1,37 @@ +--- orc-rel-release-1.6.6/cmake_modules/FindSnappy.cmake.orig 2020-12-03 15:46:53.000000000 -0500 ++++ orc-rel-release-1.6.6/cmake_modules/FindSnappy.cmake 2021-09-15 13:50:06.714446184 -0400 +@@ -14,7 +14,7 @@ + + # SNAPPY_INCLUDE_DIR: directory containing headers + # SNAPPY_LIBS: directory containing snappy libraries +-# SNAPPY_STATIC_LIB: path to libsnappy.a ++# SNAPPY_SHARED_LIB: path to libsnappy.a + # SNAPPY_FOUND: whether snappy has been found + + if( NOT "${SNAPPY_HOME}" STREQUAL "") +@@ -38,14 +38,14 @@ + set (SNAPPY_HEADER_NAME snappy.h) + set (SNAPPY_HEADER ${SNAPPY_INCLUDE_DIR}/${SNAPPY_HEADER_NAME}) + set (SNAPPY_LIB_NAME snappy) +- set (SNAPPY_STATIC_LIB ${SNAPPY_LIBS}/${CMAKE_STATIC_LIBRARY_PREFIX}${SNAPPY_LIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX}) ++ set (SNAPPY_SHARED_LIB ${SNAPPY_LIBS}/${CMAKE_SHARED_LIBRARY_PREFIX}${SNAPPY_LIB_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}) + else () + set (SNAPPY_FOUND FALSE) + endif () + + if (SNAPPY_FOUND) + message (STATUS "Found the Snappy header: ${SNAPPY_HEADER}") +- message (STATUS "Found the Snappy library: ${SNAPPY_STATIC_LIB}") ++ message (STATUS "Found the Snappy library: ${SNAPPY_SHARED_LIB}") + else() + if (_snappy_path) + set (SNAPPY_ERR_MSG "Could not find Snappy. Looked in ${_snappy_path}.") +@@ -62,7 +62,7 @@ + + mark_as_advanced ( + SNAPPY_INCLUDE_DIR +- SNAPPY_STATIC_LIB ++ SNAPPY_SHARED_LIB + SNAPPY_LIBS + SNAPPY_LIBRARIES + ) diff --git a/SOURCES/0005-cmake_modules-FindLZ4.cmake.patch b/SOURCES/0005-cmake_modules-FindLZ4.cmake.patch new file mode 100644 index 0000000..dbee644 --- /dev/null +++ b/SOURCES/0005-cmake_modules-FindLZ4.cmake.patch @@ -0,0 +1,37 @@ +--- orc-rel-release-1.6.6/cmake_modules/FindLZ4.cmake.orig 2021-09-15 13:52:14.544322930 -0400 ++++ orc-rel-release-1.6.6/cmake_modules/FindLZ4.cmake 2021-09-15 13:52:31.791036461 -0400 +@@ -14,7 +14,7 @@ + + # LZ4_INCLUDE_DIR: directory containing headers + # LZ4_LIBS: directory containing LZ4 libraries +-# LZ4_STATIC_LIB: path to lz4.a ++# LZ4_SHARED_LIB: path to lz4.a + # LZ4_FOUND: whether LZ4 has been found + + if( NOT "${LZ4_HOME}" STREQUAL "") +@@ -38,14 +38,14 @@ + set (LZ4_HEADER_NAME lz4.h) + set (LZ4_HEADER ${LZ4_INCLUDE_DIR}/${LZ4_HEADER_NAME}) + set (LZ4_LIB_NAME lz4) +- set (LZ4_STATIC_LIB ${LZ4_LIBS}/${CMAKE_STATIC_LIBRARY_PREFIX}${LZ4_LIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX}) ++ set (LZ4_SHARED_LIB ${LZ4_LIBS}/${CMAKE_SHARED_LIBRARY_PREFIX}${LZ4_LIB_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}) + else () + set (LZ4_FOUND FALSE) + endif () + + if (LZ4_FOUND) + message (STATUS "Found the LZ4 header: ${LZ4_HEADER}") +- message (STATUS "Found the LZ4 library: ${LZ4_STATIC_LIB}") ++ message (STATUS "Found the LZ4 library: ${LZ4_SHARED_LIB}") + else() + if (_lz4_path) + set (LZ4_ERR_MSG "Could not find LZ4. Looked in ${_lz4_path}.") +@@ -62,7 +62,7 @@ + + mark_as_advanced ( + LZ4_INCLUDE_DIR +- LZ4_STATIC_LIB ++ LZ4_SHARED_LIB + LZ4_LIBS + LZ4_LIBRARIES + ) diff --git a/SOURCES/0006-cmake_modules-FindProtobuf.cmake.patch b/SOURCES/0006-cmake_modules-FindProtobuf.cmake.patch new file mode 100644 index 0000000..da65b85 --- /dev/null +++ b/SOURCES/0006-cmake_modules-FindProtobuf.cmake.patch @@ -0,0 +1,43 @@ +--- orc-rel-release-1.6.6/cmake_modules/FindProtobuf.cmake.orig 2021-09-15 14:15:19.726344469 -0400 ++++ orc-rel-release-1.6.6/cmake_modules/FindProtobuf.cmake 2021-09-15 14:16:22.330307272 -0400 +@@ -15,8 +15,8 @@ + # PROTOBUF_FOUND is set if Protobuf is found + # PROTOBUF_INCLUDE_DIR: directory containing headers + # PROTOBUF_LIBS: directory containing Protobuf libraries +-# PROTOBUF_STATIC_LIB: location of protobuf.a +-# PROTOC_STATIC_LIB: location of protoc.a ++# PROTOBUF_SHARED_LIB: location of protobuf.a ++# PROTOC_SHARED_LIB: location of protoc.a + # PROTOBUF_EXECUTABLE: location of protoc + + +@@ -54,16 +54,16 @@ + get_filename_component (PROTOBUF_LIBS ${PROTOBUF_LIBRARY} PATH) + set (PROTOBUF_LIB_NAME protobuf) + set (PROTOC_LIB_NAME protoc) +- set (PROTOBUF_STATIC_LIB ${PROTOBUF_LIBS}/${CMAKE_STATIC_LIBRARY_PREFIX}${PROTOBUF_LIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX}) +- set (PROTOC_STATIC_LIB ${PROTOBUF_LIBS}/${CMAKE_STATIC_LIBRARY_PREFIX}${PROTOC_LIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX}) ++ set (PROTOBUF_SHARED_LIB ${PROTOBUF_LIBS}/${CMAKE_SHARED_LIBRARY_PREFIX}${PROTOBUF_LIB_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}) ++ set (PROTOC_SHARED_LIB ${PROTOBUF_LIBS}/${CMAKE_SHARED_LIBRARY_PREFIX}${PROTOC_LIB_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}) + else () + set (PROTOBUF_FOUND FALSE) + endif () + + if (PROTOBUF_FOUND) + message (STATUS "Found the Protobuf headers: ${PROTOBUF_INCLUDE_DIR}") +- message (STATUS "Found the Protobuf library: ${PROTOBUF_STATIC_LIB}") +- message (STATUS "Found the Protoc library: ${PROTOC_STATIC_LIB}") ++ message (STATUS "Found the Protobuf library: ${PROTOBUF_SHARED_LIB}") ++ message (STATUS "Found the Protoc library: ${PROTOC_SHARED_LIB}") + message (STATUS "Found the Protoc executable: ${PROTOBUF_EXECUTABLE}") + else() + if (_protobuf_path) +@@ -82,6 +82,6 @@ + mark_as_advanced ( + PROTOBUF_INCLUDE_DIR + PROTOBUF_LIBS +- PROTOBUF_STATIC_LIB +- PROTOC_STATIC_LIB ++ PROTOBUF_SHARED_LIB ++ PROTOC_SHARED_LIB + ) diff --git a/SOURCES/0007-cmake_modules-FindZLIB.cmake.patch b/SOURCES/0007-cmake_modules-FindZLIB.cmake.patch new file mode 100644 index 0000000..813c4d3 --- /dev/null +++ b/SOURCES/0007-cmake_modules-FindZLIB.cmake.patch @@ -0,0 +1,52 @@ +--- orc-rel-release-1.6.6/cmake_modules/FindZLIB.cmake.orig 2021-09-15 14:20:04.485626684 -0400 ++++ orc-rel-release-1.6.6/cmake_modules/FindZLIB.cmake 2021-09-15 14:20:33.448146843 -0400 +@@ -14,7 +14,7 @@ + + # ZLIB_INCLUDE_DIR: directory containing headers + # ZLIB_LIBS: directory containing ZLIB libraries +-# ZLIB_STATIC_LIB: path to zlib.a ++# ZLIB_SHARED_LIB: path to zlib.a + # ZLIB_FOUND: whether ZLIB has been found + + if( NOT "${ZLIB_HOME}" STREQUAL "") +@@ -28,11 +28,11 @@ + NO_DEFAULT_PATH + PATH_SUFFIXES "include") + +-if (NOT ZLIB_STATIC_LIB_NAME) +- set (ZLIB_STATIC_LIB_NAME z) ++if (NOT ZLIB_SHARED_LIB_NAME) ++ set (ZLIB_SHARED_LIB_NAME z) + endif() + +-find_library (ZLIB_LIBRARIES NAMES ${ZLIB_STATIC_LIB_NAME} HINTS ++find_library (ZLIB_LIBRARIES NAMES ${ZLIB_SHARED_LIB_NAME} HINTS + ${_zlib_path} + PATH_SUFFIXES "lib") + +@@ -41,14 +41,14 @@ + get_filename_component (ZLIB_LIBS ${ZLIB_LIBRARIES} PATH ) + set (ZLIB_HEADER_NAME zlib.h) + set (ZLIB_HEADER ${ZLIB_INCLUDE_DIR}/${ZLIB_HEADER_NAME}) +- set (ZLIB_STATIC_LIB ${ZLIB_LIBS}/${CMAKE_STATIC_LIBRARY_PREFIX}${ZLIB_STATIC_LIB_NAME}${CMAKE_STATIC_LIBRARY_SUFFIX}) ++ set (ZLIB_SHARED_LIB ${ZLIB_LIBS}/${CMAKE_SHARED_LIBRARY_PREFIX}${ZLIB_SHARED_LIB_NAME}${CMAKE_SHARED_LIBRARY_SUFFIX}) + else () + set (ZLIB_FOUND FALSE) + endif () + + if (ZLIB_FOUND) + message (STATUS "Found the ZLIB header: ${ZLIB_HEADER}") +- message (STATUS "Found the ZLIB library: ${ZLIB_STATIC_LIB}") ++ message (STATUS "Found the ZLIB library: ${ZLIB_SHARED_LIB}") + else() + if (_zlib_path) + set (ZLIB_ERR_MSG "Could not find ZLIB. Looked in ${_zlib_path}.") +@@ -65,7 +65,7 @@ + + mark_as_advanced ( + ZLIB_INCLUDE_DIR +- ZLIB_STATIC_LIB ++ ZLIB_SHARED_LIB + ZLIB_LIBS + ZLIB_LIBRARIES + ) diff --git a/SOURCES/KEYS b/SOURCES/KEYS new file mode 100644 index 0000000..23e0f59 --- /dev/null +++ b/SOURCES/KEYS @@ -0,0 +1,1173 @@ +pub rsa4096 2010-02-23 [SC] + 47660BC98BC433F01E5C90581209E7F13D0C92B9 +uid [ultimate] Owen O'Malley +uid [ultimate] Owen O'Malley (Code signing) +uid [ultimate] Owen O'Malley +uid [ultimate] [jpeg image of size 12030] +uid [ultimate] Owen O'Malley +sub rsa4096 2010-02-23 [E] +sub rsa4096 2020-04-21 [S] [expires: 2030-04-19] + +-----BEGIN PGP PUBLIC KEY BLOCK----- + +mQINBEuDfIYBEACqHN0qz+qyglzZVDBqOADk6ljBO09TqplCdLtXUoYyTr7tHBFq +1tPoBEqiQ5esfk/8Wf/QDnEz0EjWdpekfFxjrW2uIqMHXvSFGMm4bW6ubm7hDw0V +ZKaZbwT4nx/wgrweoKMRK9HJoJ+PLUvX3kGcZU1WXYU51au1SaCl757uy4hlWOQS +Mr3Xl8lgbW/OtfDEj/uwO4RZ6apfNx0/4Z8EhKwYOFzkF72hnLWDE7roFcNr03w2 +tT2n6fkWx4vuHJABzznGJHpsdUO7uQnAamIFPu6Ji4wpldhHksyV8aGNIReJQD9F +zKl2Mm+U1wgrmEn103HHzGsBNTDdP41JD8usJ7WaOrAVkeoaw4Tv4nBP6X3FUF/a +oTvhry3zPJolIp5PNYiNFX+Pay8yiskL1GbBCBBvzK4FpKOq8rA8y8G0JznnxwX0 +ZbtxZW6y1/M1d5s3oSBYOWndszhK+CQv92LSVdlIckU95i+hgMR74mD6TQ+k7AdF +Vt0zCdnMa9ADZrptN9+4CurIwhXiH8Gh89Z8uQG3iH3+NpQuEnUqwWGVYNNS/LoQ +rNuHp174HohkUpKECN3am1ZwpLaz4W+c27eLQBKvFlzii+u4PkIWOAl5fHhfxwvC +G7RcJI/JO2VPcYF3hEdtN0eqTEvuaY3b/Texc8i5mM7oqQ7BT7HXgqmVgQARAQAB +tCJPd2VuIE8nTWFsbGV5IDxvbWFsbGV5QGFwYWNoZS5vcmc+iEYEEBECAAYFAkyX +oRIACgkQ4ip0amjjJ8FaLwCfZDlzXk076Cbhpp83Ert0gJ++nBMAoIfYU59OeeBn +m4Ai2wLvjr0cGjvPiEYEEBECAAYFAkyaRZYACgkQQXT1Qzsc5s/3YQCZAf3KK0A7 +ptYPA6gOKoF1SYboF/gAnicfSnQcpVpvbtCpfKHmnn/IsvipiQIcBBABCgAGBQJM +mkoLAAoJEPrQXCrFJpS4jrkQAI55nDgtR5ltK69JIYB1cpFVQPcI4nFc3SWWdlyN +YiVTZG481jXnyO5VV4+EWkBrqAAwcnz0cIpQOyUjHSOT06uL4sTZRI1QQmq2cjVA +17V9K4B94eOVnSlj+3k4OX3xS2sHpatQpju8naNc1kF7HJkzqRkHKMYysFn0LUvd +Dh1qDPq03GtLvfYe2Y64ULFbzyGwLiokMKMmaURs4h/N6OE+SV0LKD4QzOYU08/h +uAPNmJ2ia7ryrYTfUNXperByTwkGgwGlSBe58Hiv2WyBFATSgZhHOIUh9AOaQKUK +p/+RzBrsWQhJxn853+WJo0r4auRoJJSaQB3PO+lCqMorko4h54roMB2f/G6pfS3n +deRzsiEnXORjaRqONu83q77LYoTpjUARICn1X+9Cpn02ohRejxOY6g7ccMSuB1H9 +mgR4JbdNX50hJvNAFnUu9hqok6Yk/me3aOWiy+RRIY0cVetAj8fLqct9jxCA3O53 +zktws5Sj+HcD/t73xOyqtFFm23jvpN8HmdduYj0jy0AfGiGjo6A+23rXz7jtygOd +Ca/Bd64oaElj2Vh9AvyJYmiCHgDwYM7z1JyNhlm4rR0WX30GG+1NKw3Y5yeyb4oM +WD9ZSCh7myIDRQNuDXqXRltBKLtcZLpZYVKyxSiEpoCejhoI688Ewx5NMDe/CeJo +4uvWiQEcBBABAgAGBQJMmnHEAAoJEN8PW7wwzQmWItsIAJLrZo+hfxQ/jiaGTIb5 +R8O1EcIHXDWoaabBLM5KUyftFvc5OeSQ6tDc6rxhdJcCY72vWNqYbfmXo7pUY5i9 +NvrShUv8tYupZP+ZJse+4hfya/ym/0L0tGXhx1MIx9NxMjY4X8isKv0V8FvY2Z6H +IJT4fEd+wcIt62CrGb23xrFf5Rg6rNvkGI5tA7t1jhPM9w4oUfU01wXrdVT/bBk3 +Rpl/yy7p5RiF5Yreqc9uPoTqdKuSADOm82ulCcpUddB4dv9JLEniGqJ9eL7inMEH +SySHINJMxRBiI/WlSwnGR/MRq/s1httWyEU6IUQf8VPR6K+7AuLmfSIZwgZr9HAX +SYCIRgQQEQIABgUCTJqW2wAKCRD/FZqtdPDoOZU5AKCBWzquu/hzZZZeO61ZoMFj +SivTtwCgxV8WeWYNsyCGNZo+MTy8fHMEPmqJAhwEEAECAAYFAkyalqMACgkQxZMp +fd40/qB75g/+ICZkubcbUpHxApMx/I/4q/v+nsqbI7FoFN0ztoJ6Cv4Xyzq1zr+A +7oYcZPSQO/IMJQN7X79YVFncVCBcGiOhFHysbt+UKQaZBgpbihSOwvej9E9rIbsT +felapAzJ5nCIocn+tZIxgPSopeOTx+tfXBQgwYu9F8+PCxrwHO0ZrTD32vYoPvhr +lzXHC9CxAiLOIYu0kqmluYLMVPaV/hYsarnn3sqvkgjsEfnOzVpf8BqUCnxn8lCq +6d3q5C6mB5HMyHQStbvDZKvt7eGwP+mGyVwGmJpkVjHuXY2EiwVRIHPZ5pi81Oh4 +0QzVHtikjEUXsZhoiaDVdqDkZtykVf51TvNcKz4jSWrGYNk+Au6uXH+bmXBehD8z +E2fYVLCyhoqAtx65tarEj+qm4Qq0taYMUdcGWbmL348U799gMxetVGJ+J4zlm83G +fwtKnv1zsD1Y8SdYg1wL8G6FbEz4dnO4Jck9UlkJzrQyKryLysSO2trNFEmFBIni +Sa9oPZOF1dI4uwJT26qVggpAvOOJ4H1FHITMeqGiE5hyUl+8fcl+2ZURfU8q+sq5 +rJVkDPgzhr+zBZ80g83CnIbOpDF+lSX20OkLl+jbzE2ijErWpQDsgzInncirh3oz +sOfsV4Gb9Teiwr8wr4a+CQsNFZTjUvyr9o2YTEsUr1AM9/NLeDs/tnKJAhwEEAEC +AAYFAkyc154ACgkQTzlV2JSc02AtKw//Rt22TQZMlqY/t9szSwDnV9iMO67jwZ0L +Hp+xekUFuQsXAUaJHje1JI7t+BrmoN5TZFZAF1lZJpFop7A+s58/qs2glTEion9L +dcKDXbOnEuw9eK5MmRT2C8/p7vvPmQiUQ4MD5idFDUGl4+QCKUpOA4E/A0z65sP9 +q+0+sn7wnKL5Dg31CYC+O2JQHqWkeBCPDj77oApdz5u0wjUDJ1e7Rq1mLWtpVBfY +DcZZrpSHdI04s8v/23/D8IyKIC7lXpH6hEt7IhPskHCIwvTpxSaODr9UpegneN7S +0v9avXMBCQyVanRyh6hReQLyL+S52nAZtj5IgLV73Kti+HHdUWU2YgodCIHTUQeS +Y3RkwYHcan9cykfO88o2SiHUqN1K8Yi+qjKuFDIxUSpk1eNGPPAt4z6F5c9JOY1K +kfhOYq+9tcrWFvJPGY/V6lfHdgD/ZaVhO25ak12EAZwZWpP8rAQIK3H8NLUNIw1k +vh+S+biNPgJiJUcRuVXxINbttIxAf3GyOlmwRv6gy5ALcCisvW6cFVuRgIUkRAAE +DXQezgfXUbd26NSe6fnhsCfQz7lSOcfgBtd0vAVix7U2cf+zjSJqOLdK+AQ0vB8D +WVCIe1boIba/mb6mwAC4c3a//+fXJMonmDxfGNd17XCXu9MWBFDEJ6n/7u3E5Duj +yw2CvLVGSaCIRgQQEQIABgUCTJ0VmAAKCRDbr2m+pyOdWdFFAJ0UzT3k3UAhq9FB +D50+yHqD0/ZzVACfYYDpMNp/5EkgXCMCQv61dqYxRneIRgQQEQIABgUCTJ0qcAAK +CRBPuVWFQxj2aQyAAJoDl9yrOPm/vODJM/IK5rqo0RtcxACcDAvF9MWc10iJRzsP +5l7hg7svTTGIRgQQEQIABgUCTJ2TkQAKCRDpUvRZKZ6zLHCMAKCM+RwZu1i7N8Yr +6bOF0tJCs32ZlgCfQdbfJb/XkkI7S2NUpn0Db/Om+U6IRgQQEQIABgUCTKELXQAK +CRBeQ8q5rsd+r5qKAJ4iY4bJOoWv5CJ/FXPHnt+B8UBtfwCgxvhM17Kxd9JRXiis +YD2XuT2ePI6JAhwEEAECAAYFAkymfTQACgkQLInumMmHIA25FA//Ux2/fYwgG49y +Nx/J0Cj2pC5GzJSkOzGD+QnXTjjlnraPwUBJ6HwlKk8INAZA+IcQrAgDYgS4DJl5 +YZWmqTaFw/cjNyI54h/U++npZ/kfGultfXdfo/Z1QnWjZrAYF6L3erIq7eoRXAMw +lMhnligLJ4pJk27sQKPlYh8J8EdRQ2V66k6upELZB89AiZXL4Lihw+n1PYRoMoKS +pX9fJ37uLLRhaSbhwaJvd+onMbnZ5jLvtET989a4MKpzj3XgYrC69gBaQ36wwyGF +veT50VmunFZP+dmrDR5Lu+oM4uFze4QsLhAqt8KN5qZklAvI1EXrMJddUzDlB0/K +XzGzKe8l9wi/W5mMZ6/kZKf/sigb091axrKzAprenCuXtyfuEiNaw3+PodLdIRVi +2Mss9nE0gzMpx/QTcgKpoXu7bH0nkgQ2btx1TArHt7vgvmTjLh/iqTRV+fTZJgpB +HKUMN/mH013O/CZFg2+sBXo1xSoGIxkeiw9ZxnUNL/JEtyIUASgql7OSEV6az7/D +rZmYhv/zRwHVP+NDENcN4YxhPJdoqz072tqgXGSoXBLpq6vhy1xBCDP4+L/be0I5 +vH+SEpBw1OEJfoJykpBZrjLw4Bi7y1LoT/VWsUNym/bdV/fGaaTzqycqzsOOzCDw +YbFAwoXS8DEHTJ3GaEcl7eVesXupOgSJAhwEEAECAAYFAk3SoScACgkQr1joIoci ++L2bpw/6AhcErsGLvHKoFMX2bDP0eBPZZZdWGcHsFufyfZeLupLiozCTBGTLLDso +bN/2p6e/vJV4fDo0zIwza7KPFY8gkIARJJ6Yexc2RQLe0x1Dm22i/9wrBPedIDL1 +WhyxmhIX7NUn+akaWOnxftea/RZUJ2V+dl9ZXUugNKLj5Abobi0FKgsza8kOHTm2 +51pay9onxgA7z15DaJqJNBgi593HU5zioahNhrlMm0/snL+mlehXBmW4Xrdem+8H +6CL0s6z+bWlJGmj2IiSZUYT4f7tzrZxq+m4P0rvu/9zM5UqMR0kUSvVrg4LBzV2G +iOYUA40BIjMMiev6M6UprscCAHv/Db0bfhiYwRtiCLfIjpvLVBDYOqglouVwBs5c +jXXXOOJIhdOMG/5gT81SiKxVhd5kS/KJiHAxCzdJW8X1Pzekq5AAAQNNh0MO3WEy +a4xbgbwhhjYBAJiQH25qPIZfV5HsG3hkz5DO4WZZg1YKhFEn7oem6ybRctxsyrdA +nSXIkHvlL4RtKO3eRKoINo0STO7UwLwwR2w1qRU4X4HhWH+jxrsaUwmbGYBBuddW +YJi9/kuuJDMO1BeMffuo73+6lFgw5Y4ihCpQdTrq/bZEQCaaumjblwX4KZO1V6pE +CIsy1w4jJmKn+lwgzEIiSwBNBni6fQg43dIz50H2v8RTizUSLMCJAhwEEAEKAAYF +Ak36ZYwACgkQjxiV6XhpovsTMg/+O97vsBV3NP4wfr5pfHhlv953xNnujrRahpgf +b7WJ9Zr4tXKDa3PvWjXR0yFTpqbV83CHgD9Ul0SLbu+lkNiKrbPfI1yFTH4uzaRp +0ED7y3MzZ5nECxMJX5Aw8KVYM+fpi9kKeZkwIVLnY7uh3ftmKU4DL+4tv5vhLF4O +UrpPdSxZO4OKu/ESodCWvXU3XTD725rl0/7lfh83DnoECDdZJynZh0b1dZELNVjp +xQC8q4tHnPaBfeBUuY1C6QcDnF90JkGoKLxRy88mwTOI/YQzsanrt6wHprkpui6B +WQKIeIu+rA2U6qho7fh0MnygoHjghEmjDvCYha+KJmOXt/pMWki0lxRa1ufACC4m +7KjIT2GkCsjU6nvQUAhlC3Z56DvCukm3zaqJCov2JFpPTL2MswFThDhQZNmd2gQz +c9DG63+XYl9HdM79+0/Gek1u1IN5R9DwiTSbYC7Jh7oDBjlK+Qg0B+PffTVkeEog +Ha++5gzJZoo/Ace9BlXcmV+q+EX7WE5x78WtFvQJR750ePuicOqBurHuUsYAltuC +7/0lz2xMRWolPGROWGgdpWpQZ+d0+EWv884TOd/zPvuzlaHLgTH6eWE8Rl5trTqk +uW8m2awh8EiPvmuqhhSnxnDd54HAMtWl98LlGvmxNVw/Y+O44SDOfk53D1xtP6K3 +3rpUqGCJAhwEEAECAAYFAk6uGL0ACgkQvlqqC6IQwJWB9A//YJQWA3fI1y6TDbO8 +Jfk6TAkByFuWYAsWQ9lm946+N6xvORnJgDOmS+3erLPOHgwula3sqc+uMZef2d7U +87ubdhgBnovL56l+c9NZ9ZvFXr+1+2NNBV8vYcuOgewZFqVQdw+pzVVAjAyenxnU +QigCXeHQvZo1mthOpZIJlI46wHXI4jliSLCO/GqNoVSPeHMP457xv5FdslhvcrI0 +7ojALYQ15rXZ5x2Y2mDHBnxQbjdhBokqf1wVEdmnKUv+icCpbIwn5qAV0RhYbjGV +79eQ+bMDOrvN8lIymXNGVEW9wgTh9I2TE0hcyVJ8uOF/A2oNwCoBbC9riWkWzHlA +Rw9qfKA+HxDt5ZbCt5FQd6a4g4r2MzRQ7HKL3YJBlH1btq3c7arhcFcF9OeN9mTR +57Qvb89Q+mIof8NOEDiv8+kRSL13scPbqLNc77AQPoUBnPJTLt1EQsaU0SEbWrZF +6kZlqRFG5AS2LPmu/Q8lkU1GYIHY1QUgtPURlrUHRADNvFZNcWHB/Yg3y9s9W3d9 +Coa/W1lHuIiYMZ3EA5ECtPDhQs3Qz0Ncr5tlpzB1MjMFmjR1qfhNXuKK2RN3iOda +8+dLIymMPRJsDApeV4lL5fHtH5aMc60/T5WjTEovqhxKucZRY8Bg7z/KRORg7n/m +A4P435kkcjxRi3zwkW3kJ/fx2kKJAhwEEAEKAAYFAlB0tGwACgkQQWmqJ+yzFmM0 +BA/8CwWA/84rPYX4z8GNCSb2OPUAw7Y8EAIkPCEV5nuyLQD4qkqwGrMtKqrixVNE +oDuIeH7+0V/QPyCLmOQ0jfPPUKuaPFxl+a3XW46Khjj2019HY/iayHgBahl4fqnl +Ez8vlAlU0ibWjMW6gfpWxawPNZy0irYeWFomh5An+mQHmYlTeH+0lMW8eYuzm2C5 +H4jTk47Q37JJazvvApTKy8bk+0EEyCdU8CruPUFA6P3Y6xyKP/KSW2gsiIzrqa7m +dja1+LLPTMBeYogafU2Glx/WWpz+k2MGFnsFT3v2ckxgkXOKLFM5Zlvba8hZMqbU ++ObpB1PAlkepeNJCu16tgOJJheEfPN4HjsINlgaYrBnOcZhqb9W0W7YuEsCCJ4ZW +mtJ1GHunIH1A02QoMDwhfnbqNhRjULrP4Ify4mltKmsswZegLe3wynushT2dVhzM +Gx9PykCbP5w3LcrgBvsYu40uOBN1hB7K/QM0zOPtSfLly4+j9eGQ1URExNBU+SSJ +Ht4ET5toU7wYEBwI3q+I0RGedpw1/zCikWbdP7S2Xg6E/Q7TSxNfog5tNaGBZ59R +B5lBviNkefTiZ+AdU7KvdX6SEouG1VgHiYqOkrde0ON6hsxkt8SY2xEiy1ZvKaYT +zwm7uM9JWpTiNt7bZvK8fciU0N9GhVbgsJ4rrRvrXLkfWM+IRgQTEQIABgUCVg17 +eAAKCRCI889MItf27DPzAKCeMZFGICJyi2aYXhEfhTRbY9rUrwCghwgaV0GaBQ9h +nSsMw0fBlnQ8QUuJAhwEEAECAAYFAlnlHi8ACgkQtbuVrGXEaKPpfg/+Lu1Nhz6w +GZS4zwwR4jmsYHTpnTnFNFfdj8Ah5ZmlfFoerhmTfDscsaxR+BBgTs1CBIdsCjsq +x4IpbmNHMTRkZy6Hw9oNpWzBaUNEX55ewqIaSAGpdBEsU1zKsxWOfPlPyY4bRJ13 +QDsziii7cdS8qjcMmFt4SMP9t4U9PYF2HYtOLnYM3zG7Rp2M5Y3RsyxmuWKkWv8n +hE+1BB40Lk7AYo61WdHyPNEjTtxNpfMsSF4LpiRqUmQD8RK2VowqgLyUBa8ZG7xn +kyvARfNJN8LPOvYGHiSHPPdem7Kt+hfJUJqp8N966j7i1leN85zpv8i1pV+hyQa5 +CeMVbhuRneMTycMYisifOUCcBPyuBX+Rv6zCPE2XYoqh5frsOXfoNpz2m79Z3B5I +cz03ELJcfToUAyk4f/66I1uj26MlcLts0/LGukqtMpSknRqH99vKeU8XB+SeD+Fd +1lJK9q8FVxKd1Kj6Es3XZu7f+35VtDJjQF4zJvRkw2YSfKu8t0SBZ/jhs2tMRpQh +3371Eo0ucoakfYoDQFjtjRUkVA2YofzMnKrpmuBnHqbhspVrF+NSDkktIsacmdYn +aWtkl6SAjlVOHGpZMwYXhke4NcJB1azvYEUMshiri/cPPKBiVPbDK4wbItSD3SQQ +auFWQp2nhvuzfu22It7nxqrKoSLuGVSlmcSJAhwEEAECAAYFAlsVt20ACgkQN4tE +abQASLJP/BAAzlA0n8CAsJy5KTfzbxWuWn21Y62xKlk+qpXD4T+nx1MaD9X59nad +EmzSMYIvyFeTNOJUzbkI2MnqxQHpi53B5yT3lJwZ+wlXIdHQjWyspRrK/WrQ6RE7 +77kUnYL9sqxz7d3zyUee8ykCgZr7K8BXX9PxKJ6+01U1c8clBAxnP7hw7F7XEykc +3E12tM6DPDLxlsBMFHMJZjbULWIS6pL9IT2YTXZugkg6wgQ9uDsrWzgVE7wryo/P +qlfPBOJPymMb2daJvLnlVulue7ESScHNfXDXczWZOW31H1Z6fgFCOu/IMkZNJE0d +V/iAXQvldk2b8VKr7VnV4G7CexT5LJu9AT9fdX7xrIHMqNiHlWm2RbgUJ5MRUTTH +QkfDasWOQqgRxcmIeyND3Rt3xZ28EW+AXXO3EI/PlgwFi/gBAZH3Uett1MvMNEnI +mAPdjWo9Z4/giGOvjtMlt/2jJ89yvsTPC/RFTV2LEV/fG2nS9wwi6/DfeSYUoBJQ +1deOMtRX9ILZMgHHNx5HRqnvhH+8xWHX4y3n21+6gBgPpsMSA2AiTBWc6E00RTwI +7sQDXHN+AsRq2nY0awdr4rtsgIq/q3Xvj97QHnHgItoiGKYCnFsBt6hrmToG6zja +Y+Tx1ynglNYrY/YWOMh00Vx5NouEXyxE5NMbxcKNVzFFsvocdE1sLJqJAhwEEAEK +AAYFAlkJBBQACgkQeENO9GDWkUtdbg//Z4t2EBveDN4n2e8PckSrWRlISymaNm40 +RubOL3VxNJoo26coxq7sa/euY/wygLpw+1xE19T+HGaDyNnzgx2KVpAd113AtLoV +FB+FgsgOGNXJ1wZMNDs7IzwuO89NCM0ZFSHlxQJIn862lNruA7clF8vWtphhRTwk +UO0hZq9uDA0Ns4QH6zXrNS+TcTH0BnazcVKATamYTygYNUhTxRPY5AWZEtGw6xp1 +gj3lOz4piJB8U2B+koxgl5REdmOVLE2Gm2UgfcuinFisooeJK4a5wR29wfHZdJZD +X6mCT0AUfJjsZBHKUB7nAIMIG/qqcd2oCbw7/YQMi2CMKnVnm+TSOo6/qTtwhtiY +RU0jHdVeg/tDHRpzOq2zK9Jm89YjjJc9gTDVKTCAeqmCulaScTyNpsRWH8CAuQsb +xTz0knFNFjZTYCNYFt7ju2WKy+DvFXEWMm3GZg1cw4xibixNNx/w60ZC6FBmYs3q +wxE+3vZuV1yG+TWuVDBJpkwcrvTtlRkeXP1CFRaFOTtdSwQibhiicbSPt6PMJO/p +c93gwqQ/gVBI6mLp+3Y8794osaWJfvEkarV0HZmEmofzvWMx5gZro7fk7unrSmnS +NbQGxiHf25rAUMO55PGq5cPETdQ0fXlIeD3/ODuOucfJ57GRWVfJPEvpVkrk0PQ6 +tNe3bPEIBg2JAjMEEAEIAB0WIQQc7zP6YYABF72y4ODVHqjwDuebKAUCWyJUAAAK +CRDVHqjwDuebKNaUEACkKcTcGIwqhsVsaIIzZ/fA+1E6ZOYyM/SDNga8iY60BYR7 +tkT4o0XvofkA+L3l72QcCVxIBgBvHYv2R58ibY3TQyzMEDJjC4c/X6e7N11bmqFX +r2zgWtHsUijA+478HJBotwOFVk+BFwXQWOKyAIOpYdQGa6i9itDnYhTjnH0XVfjY +86I5pKduU4rHZ6OafQimTpU0Z7JgF0GnaaVkiAi7/ptCuZj2dW4EEReElRdHppmL +gZAYv1upAV2PoooDIoNl14xGaDa1ZPJEXcrALyrLAmCQVswhKJfkXGsaf7Tg/uxE +mopWSZ1orH9L/B+HFw2ZMJ1My+T0JUeK69524/x0WY17U6zRh0RRgOAmtWkFOiUF +5fNRn0vRZSpBexpKItQG/KBidF/AVpPO9Rc2EcdogmgDLXvgedtvxc7y1zLmTuG5 +8jxfO71+55TvNJTsl7zgCy2/zolYAtfLlGKGoXiBKU5Rj+4Utr1ofh3vBxqJZlD5 +1TUqUAG2S23iSoJftdoYwLdPR5hwy+YY2aiLnzJAHrclPDt7QifpatbzneLyMv0w +prktR7erQheYqBeqRGi4kWmfhdXafQ+Sf5jO1QC/Ao8g9tV9aYjRolJd95kP0Bv8 ++k2wJ9xRvndzkN+q6TH6s/USafQvsP4Fyd4zKgwT/EkUP3SbNEMq8F1pG6UL+okC +OgQTAQoAJAIbAwIeAQIXgAULCQgHAwUVCgkICwUWAgMBAAUCWQj+cwIZAQAKCRAS +CefxPQySuSPDD/wJHN7731ugOlzXgGUXtpc2INrhxBVjQWBe0gNcuC/+tzx4EeFB +7dFSbuduRD8z1fInFKZnd++PPozVtu5yP6D7EeIFwiATnw9EllQwFktHiFg2yb+/ +4l5b8WKpkec7HN3HA+JwoSHyFk5j1IdSmr3mZR71goXK5qV/x+QpeiEjxRvEv0Zq +A65LfhDjUj+E+ms/soON2XQQ9FXMkNsyhCgY85Trxk4XrHRPbCdFvS3igLpTE/1N +JF88k5GD0ClIpirOAejUi1wUxA/3nI2U1WfRICQPIc4hTMR4c7P0NqX3gkkdgcuf +T/QCcDtGwLX3zT+9ip7dTSsQAwu5rqAonunAlHJtM+Gyd86y6EqxBnT6L/aAcpBG +HUvFSH3Xf+Le/Ud9atLnSJrnk3VncqelolZ9lkCNWpaMm62A6ENJm5pRi3lZ27EZ +flp9JXljqy8CvLoey9AcBX4EpYu1Q5c91MByyMOAWwurfOnMT0t0cB5aU6RiMlkj +Z/8hXiRijrdqJAY0y/6QqUzBRZAlZAtq3NEm5TLajvKQjAkkJfLT7ATAmfW5T/WN +ViwpO52M3jTvBZC9sWvkYbVkHQ2ENk/6RzVnk/GBO5XYCYtCkyJ92g8jsEdhACP9 +03m8sZ1BeKUh8BBvTN07DX+6Ban1mD6WX5CoYrPpxW1JWpYRTwlSUSy4vIkCOQQT +AQoAIxYhBDgjfuQlBQKFB321etIs+EbbsWKgBQJb0vZ+BYMHhh+AAAoJENIs+Ebb +sWKg9KYP/3a7XzAjZN+X0vTFTltfTTQzjd4pd5Pun4PpXabvcEtKUXbBhsl2z2Wx +0rCuWOM0kMZGGdOGxMZ2CWpKcX/BQzxq0GMmxOLuaXjsrKX4dbDApEtuVUw8LAq/ +NN3KCKDA7l38NuspusqvdSRAP/U1YoxTi/SS8bgApFbCchhoW2akzWM6M/PH2sPy +ULXRetIirzsoUOEBLg8xw5mr1L5BeXBavgEjE1fn3WFzt4lSAEnJohLhc+vhOesF +tCs0ODWik3Y4qg3H3Ipb3Vqez/C2D1dKkY5lUjHX+RQ32DYWFAaWR6rixQTKJnCx +Zkmqf3L3KBtyUcfGtYRcWNgpEqASxAqKRz40heH8dlLQjQVkATIBqPHjLtDBPUyT +7SzDJR3Y6MAE/sKdez5wfAlmBE5liB5J7R4pkH6L3HmzQ8ZcWMrnw5KxPLNXYTQq +9alnK4SVbHlvY7zQkzeMSdrtQfHXd+vhMlEf0++aWshLeUE4DLTO0qtXkKcTNL4y +lDcymwcmldnskFwR/CzoNahzAOJzAiDliMJuZeDJti+4UekyOqbEOUqjzS578JCp +gC2OlN3Qv4pO7xjVNj5LqsKNSGn+5zSZIfEUucTa3QaM+wrmzMAEKpVnmPK+yUj9 +W86KuAchcVrpKadxHir5cJ0xlIgYQ4nvEN+TZC+wvQFCu6lJCux4tDFPd2VuIE8n +TWFsbGV5IChDb2RlIHNpZ25pbmcpIDxvbWFsbGV5QGFwYWNoZS5vcmc+iQI3BBMB +AgAhAhsDAh4BAheABQJMk+pbBQsJCAcDBRUKCQgLBRYCAwEAAAoJEBIJ5/E9DJK5 +LBcP/iIun41QIFXMe560eQaf9dBIW25v+isXuYRnTlRr/vqIal4Dl/RORoh4B4nq +BsXZX/290xCLIoOw1JpAVOu9PjLC7cN1h88IvHsHlULbwC47DmXano8wM3YH5KBv +s/fOZH/7TxcATeZCRyoJWqHJcv6K+ygPW2vYx+rfODCd+4bN4JdtDkU72fKqWUFR +sXWfW6kUin0jeW+ynbwb2RhDCl0jlWy3IvU1GrsmMk/0gquzl0I+TDgMrTqGcd+j +/6n8hRsC0gxGlg/dw+HhYQuVh8WsXn+O6IVWJ/T0n1rP5KTZOBjtre2lgNR1UjlK +frRNAniJf71y1s2cR9OcDBRZ2aDUGkNL/nZp93bcOOzSwz3ysXLHJ14R0aSKC8VT +z9L53OpGWKlcMMOQLLfNFOMF2zTFu4mLOAzOSWsXPMswi4F4PZ3oi6L0wWxeHb4m +lpQwcG2HY7VAgfVuNBQTMmvctmJaAP79JRrlryT47k0qXLHJLqazgTDwSyaIiAE0 +LbkSYBdZnE1aK2q4hX8/Bifet/ZOp8d1CXqB3y9I8+e8bTF8Al45C5lIchXeYvH5 +yu4bDUWi44M9ypay+9lVap+yQm1YicKo25U+FORSp5Fa7WWHqkSYmZ7nEDC5uC9C +zQfqnJueZ40wfWRjJW5GW/5mYXFWPxgoOOuLqtZgB2iWPogniEYEEBECAAYFAkyT +0skACgkQo/Xcc0IABGI7ygCgpNxS0Vl44sx0Am7jngHmRxH33d0AmgIbIS6L8LPG +zjRYlQOie+wL4q7qiEYEEBECAAYFAkyXoRIACgkQ4ip0amjjJ8EB9wCfasGKOlsG +fZBgR26lgMOpE/6km3EAoJvpIq+ewLRGyBfsnPO84LByvLmniEYEEBECAAYFAkya +RZYACgkQQXT1Qzsc5s8ZLgCfdSUpVN/V2e9Pyg36PXPtN3Lbk3YAn3o3VwesFhyM +d9+E3aBz5eFxvA2iiQIcBBABCgAGBQJMmkoLAAoJEPrQXCrFJpS4dMkQAJyDBhpf +o3VR6r8/Kuscd6w7ussNtYRV7Ej6XY1xCKGqOLg1afJxf2G7OGgbOpY7BkmAJAog +IFS03b6OF7lO8YuIvsu50lonb+wcDI3NtGsLIQq8FuuvpdGqEBdpN4x5yZslXnQS +CyeT0v89kKVgu5PCHRqCZ+9sfyjNoHdyFxRpMaQl6IeiX7v2Y8otFCMwY3j4jpnk +E2ULVKppg/UBrGwTikYaxnFkrK3ldp0SER6jaxHt0rPqdFUiOjK9mJNAHYO6nFIp +G3c5AI1dYtvi8M0OOdD3l4XGAs3PgebBkTAbPkEbznlvroTIzs6jPEvdQ1OIGthr +G+1TeMt0v0FXJ/MnjfHC1ztFTgL1akdqL0y7F0MZujCbzXi4WqlMuCiqA7U68Op5 +kEdMkesn6UKIRQmYLJ5npus6N1A3O6rUGPEa9+ZAODuf/SMYKl98Dor7VJbd+i+Y +R+jEJ3Z7vqR/mgFgbgn/bvezlAMQXrslijGvi2xk4dZIMpYuoTZfLN5UIDjD7RIy +7/OIEmknnXjknZHf7Tykgme0bvbzOHU51kh/8YMX6eU/RorTf1P51VDlUU9E6mLl +b0VTYceaoGRzNyL2opW2pkaQhyrWwEeq0xOZg2HmvuliXDqu7ULBUxvK6K2ETVxG +PNwV/CAMC484YnUsiWcVP4iOOUg+jCXjHrttiQEcBBABAgAGBQJMmnHEAAoJEN8P +W7wwzQmWc1sH/0ycvRmvidezNJCcFyo4PWN0a4g8sltXBVkdEcmCwxqAiHiK4U4E +VgI10N1lDUuyG4E9APv2U/Q3ph1mrc56X49BmKqYA+Lp1ushAePMdf+4Nh+hqINq +REwssMPjCP5QCSC9zJ0Q8g9SrWi4rP+9wr/0t+ks5cDgRyAhn0mrVfvdJbdCXD7z +txdCFJUpgTbWG2eZF3+SDgAc5car0x2TsTeuFh6ubXdC7d9rx7zzkAgOEHa9nDOs +cAznQSoP9VYcMX87PvqDymBO/nTCuPEK6t5drT+L4RHjk1O0fo1lwakPIbKdOBfi +zu5Lc0znca05Nmp0Ofamhda5JIKPlZbM3nCIRgQQEQIABgUCTJqW2wAKCRD/FZqt +dPDoOcdiAKCpQ+NgkBOYfnJ4T82QfjV3boHavQCeNFbRtu3HNvqxz6/AsH6aVroG +TV6JAhwEEAECAAYFAkyalqMACgkQxZMpfd40/qBPWhAAqOhC7HD+TNDFnPFP+jRi +9P8MIRM3SUWsR2yL1WJ6Ku0irc6gxwKqZ7VxusamAzG3KIAwXGQOljIaSktm3mjL +z2iFnQe/WjXDo2Gq3ORDHvk8XRhOVUHL3ann1IoSvKO1J7laq0jV+7zKbjjXJJIi +GFzTf4pzFwr5gU8dAshWknrTBNxb3Btfnw+V6QVL/hM1qlbdbaW43AsHRsmGlT1f +Gr6cEdCRqyfzp9NnBmTpfkNVAnll62JKbC1hlETJ78ISf2/LKtmtA+bpZdJ10pid +8J/C7eLdrfy12ROANRqPCbeTvGkl3QZaS/1v/8jf7qpwcTk+7ZRea1Kszv0rmmxF +Cc60XXpNLOAmz8RvQ2S/qfcHUKIB/TvAZCfIEPQMFlwLIs4CBwUkU5taEK4UjjgT +IQiGI4iKC4S7z/V9i9i3Z+dZ5OHHJSfd/418YWIix6p4seWn0DTdwaP27ngQsx2x +fHet9hX4GNs4iIPIJoqpEIWR3JyB+Y8o1q9gY1+W65C70eqpov7d9wNR4zETis3y +35LFETgWWJn+KDBhy1Hj5Og5nFOmQQ1RhzE/+PUrYCoR0pIAvwDJ2c5OjoLU4y8a +W/4QgwjPnQ69vj7quw3WqdTzNSug2G2VK/RCPqHNvZX4IMvDtSgSkIPPO7CNSoDa +PwC0TXoxxPu8EdTXfe7KALiJAhwEEAECAAYFAkyc15gACgkQTzlV2JSc02DiaxAA +mww3KDMp0EZBlvIacDz/MJDkN2e/Uwn4surtnuNierG827zfjJiWaj2zki0icG6h +VKmH2E/jAL7W2OhyR4bR44OZLgtDjtCyfcY7J9uUtaq9NUxIWnWX8gEq/42r8PTu +zQ/OcGGwh/84i8gFFMj7WzJM6CUYsE8su8lANYbM6gzPW0SyYdWAoJ4pRvDXUb53 +CxHZfsjWzjrHVj9gjrnxDvqxq6pfI1J68J9MZFg0SeSzaqzGglDxMK92iJGWy48h +2eNppsqzUfme8cnhkFEsYvs3/py7e1gQCAd32bXcd+BZfiAn60nOKKJmcjNxhWFc +uOZeEEgDAP3yyc6e70Sdlv/oQ9o79k+ckNFZmJb4H4IlHhWXOPCFJQvGBrllSopW +1SmpkQSkIh9nVFVLt73BNVzv6fAUystr3q5sW3ud47n0FfmJ/Lld3Yx0+WQX2YQz +AKxV04WI7rz4Z45NXWx5wn1b+rjST0gkqcqD7cl6UhKKhmDvYNgy+eIc7FA7O2n7 +vSwZRxZbsCuhTy1CY9JfLGKOAxLH7ScZ96pfheD9BW8gEapUWdbNsipEIhPQsCmX +6m3wM1IMLSKzuvFQHzbdgHXEoC2w22+l+njzINwUR1Smp1cX+RKk90duDpYRuQwT +muwTFEEyiQf/Q1Df74HNlOpIxnn/yDBg3aH+yICysoOIRgQQEQIABgUCTJ0VmAAK +CRDbr2m+pyOdWT36AKCHpnwtuWK/oMNLLIC7XTT4MmPKZQCcCpHHaF1AQKJi3SW3 +nnhLdNDVmyaIRgQQEQIABgUCTJ0qcAAKCRBPuVWFQxj2acreAKCCYpuyJcFW5lWE +aDK9nvFQQd0wdgCeJs8jHRzdFwczjUXaqItCu5y71QeIRgQQEQIABgUCTJ2TkQAK +CRDpUvRZKZ6zLB1PAJ4nVXo1q2wx5Zkqoh+vTJusxkv4YgCgiW/FkEl0o9R2MEsE +6fLgPs6eEOyIRgQQEQIABgUCTKELXQAKCRBeQ8q5rsd+r6cpAKDYen4+wDC6FTT5 +8uEnIY0sWV+bbgCgn3j/1nlmsvOawtegQEEVu7oOfZ+JAhwEEAECAAYFAkymfTQA +CgkQLInumMmHIA319A//ZlSh6CDPNf3bICNMZ3CtlJPy14oGpoR3EbH7zod2mx1a +rTtOb5mfrpbsfoQqMkgEEYyYPEucYZaA+SMfQrNr0y1Djeb96ApLaF1eZhQPDSBg +8txVBplkLb51bsVU+P4FbWKw8JhMglsJpIWHD2RwkAmZ8bLuUwFuuuXNzuPGe6qB +NjlrOc9sBazALnk7tp0ia+C0tUMGp59umg1i22XuEU7VriKIBN/3NZPYiO1Zz/nS +Jdbeiep79xL6emRTmpwGGZgNBV6jxoQuuSD/uUfo7W7YKauNqEtESO6FETsJDP9H +JaiPbNfOGINtAOGK0tVNs6a+Bl5zfLzDRHb6LfZ+dvPpLcKwHB5WWPf5k0sR9CoU +aUxECBq5lrD7NlNKZLFNPbwSYjkr2cv6T4o3EVcSfkDxxFSheoNYZQ8ovGuQpSQO +DzWG5NxsC8YCy9+/pK6f9wHt78oHt3bxpRSALrju3YF/OJGlFCcBmcTh2a0SWqFd +MFW36J8CWdnbKgGrjOoofRfvtufxwBzAtToXWXcuTjLDjWl8fd2Pkmt3CofTYcGd +WH++Ze2KJPnqVLte0lUPTbRaBTNQk+UXeMbjg00FAUU/ISBtJF6I3gm9Z4U/fDbw ++hxanTMT691bnNpaHkBwhQt9OixuHROPM1IB8Nkyo9RJJiY/IRuTmBdfCLCeK++J +AhwEEAECAAYFAk3SoScACgkQr1joIoci+L3zmg/8DtotbAhSS4E49o8oNyCpSoo4 +BCeKB9qIeHhdCKE5E1E1+FytE1wQZ7v4tW5sIF5KdDwuIexKrJXuSjn/PZMWTRRA +hM3KDu7WK6gHer3AYXX7egiGBZl8Gfh7kIe1tk2HnnZPs9h62FXnc75HS9UUcjXz +ZNj6P0JGw/dmWIX5LkeCe5VlulYw79g91MnOTv1wRU8HbHppzxT0YeSJBSoD3sQC +pWFAgg1Hc2xEPajolhxl9SmKceS0UV+8yqFAdCp5BEiodw4u21K1nMhXyQ0QWo5u +Q37AzKnwOf1a/Oaij2mAAF8kwSV6j/YecdEnv7BI1CjLwLhXZ+GOxAdUvqWDJmP2 +hnnylQpvw3RYqXA1uj3i2HH0U5O8tIjkSL9jxNanSGq9VeLmVCaBvRbbdZZigoUn +A4n7PUQyzzRYrKpC0mnGUa/s3zNdJ8DtIK3Anf4uAvkcIYf+rLKGVemBqYl+R1a1 +EqzaCEVWXUWK0umpoRtbQnYuhxH8YXFLZHRnp0LmLR7jxLrpaWyRsLJSrdnE94CM +osW05KKVjnyoWESbCvXuMfNvhAFtXxw7KWxPXIqJQxuvGUr2PwHOdbW+KwA2wRa0 +GHLrRQRdmSb5zDUHmtIMy4QURudOp+AA7/NQ+j3jNT0nFR30WnsKIFM4UPY/sNzM +2t7pzr5p86sSuOOhpsmJAhwEEAEKAAYFAk36ZYwACgkQjxiV6Xhpovs4mg//Sxlx +Rj2cKKb1SNU/z4HD/xoh+0gh5eXnvg3jwcK0w2vsDJLJMc+fYR3+kqwO6IgQweHx +N3g2n+OaeAQFW7QH5ZFojqsU936rEyCCMXDcwjM8Ccbo8Hp6rXWri0SBO+peC3gY +rg3Dr0efUeqEiavVXDfp4E8+de2/VCaCmLi6T7J82DApQGMav32xfGpOFvXF6zSA +KusKsVZPZS1OjhvvYZhH6X8askeHVO0ieD57ZnjYEOvU5+Fd4JF+xtKMsQZSgqFA +4Eqnbetrq9OFSOznNqhRVzY326xIAz4/JmIPPYI6ZqZzyWrFWuOc2VNuzNyHXJU3 +fgZf8AOj9VsXM5ykxWnGEoYQ2LbN9JzlWCwgWOArsXK1VBU5csUXkNc2eDq4L35+ +5VKhVYcfFY6ZNyfIdb6fGI0k75Rn0FbX61yNJUj6X7QgzMRg8XBxD+O9EVKnCWrX +nFRmOQ/fGpTj0qoLdCAvQ0h92E1G//bOCENy6bUVjnotTzRyTO4DUVlweURxMzY6 +21uCiWmkVb8Dm94p6NZ6ihffDwJm45yZ47m9IPhK51OXf5FanolzQXotcHyxQAUK +asTwOSDZdaTQnAcptddFunM0bLLgsYUVc4Z6jxP8J8d1SLjluQnrWh7XuhC2hvJo +YQV4w+AwqyoYA6DWovfp12e4TEBGO2ZFE6gB1uWJAhwEEAECAAYFAk6uGLkACgkQ +vlqqC6IQwJWohg//RnDSuG11xMjgNytBkrGiW3iiO/MRzsEmu9EG3yqIGMZ4dVt6 +rfl54JLzkzA+nYYMvAGdR1FxfrRj4U7wM32TmDjvte0NG8KhXkQfUozUY4r0KkqJ +9S41lebVizwI9jlu956DB64yGrAdfevszIr94yr9ZCpwr6vIo6rEsUNfY/xQbcm/ +ibu7eo/JSJtQ5iuP/W79a38A4b+aqRbUNlkRkEG9iUauhx12CPFzJm9ebQ2jHuz2 +CsVBTAyR+PJXxmQE4U7k8iYv2lKjzOGR52SbsDLQ2Omp0cgGCzgnU8kYjBw0aetk +8i+61AdAdWVHG4Jy/q/2trVg3wrGZE/AzMZ2m0Q+ZBKrhYv60riKRfVbro56UpT8 ++xQWfC3Yl+MG9kIFDxHAJdOxZOCiw2sjFc3dAhbzarOD1xDs4o+GzpqTFW1kALOg +pQOMDgUEaHY92q8MNltUmaKO0Bq+ihc22kFCNtv+vtwV7GHXksdnBXFXfBx1gIFY +yAcnXhhTXy1WzLX+F+BbbfzhTfE6pd8L5GhNqEVu8a3q/8end/H5EeghQZYjGyf0 +bB5+PH9qufyGqBq6ZG9pZxwdHz5ljjEUW3jPrin6sd6oWlnnCTL4Xlv3LJZYgUih +vzeU0bn6OMHsTBCAJJ9hMF5+fOviSjYmNgN3qZ9FfX2CQqgNyd41q3xn3laJAhwE +EAEKAAYFAlB0tGUACgkQQWmqJ+yzFmOW0w//R+NSNB28Rtjyf/NH2rDgxT/CD3yT +HovMNdyowKmyeHvyHOdn4vOB7XiLsKZQdgA8/agDY6uq+Z2q6iFKNgHMwvfhdDo8 +tZeId0Wy9OCwVTaG3vfyKk1IEO2fcBGk0AbwMr+qJNoAuSXbTjoFxbnxcSYvxHHV +BvH+zJIXx7loyNPzqswdxjxVZ+cVHw5mEjfe/IYi+qCMHcMLHXCndJFEyC7EjWv8 +KHBKwK415YloucslWVGyGk4m53bSRx0alG4MxnNVGSFy42YFt2YNy1UoJ3Ff0LVM +/Uyhiwp9RWTVKntNGunXCkhWDzhg79/Z3nBzJfc6R3hTQwAOXuhcImZL3lsYzmqT +mvQdTVMRLfy1px04tp08XnDu5ABxiPcdCX/GnHw2iIwdNZq6BwCEHNW1FAYIofMH +Jg8i7mxENdrXVKg446VOeb6fpgbTMPJce0BoJUy2+ofyjzyhZ3TtMS0JsepGC+oP +zgQolTr+o6OPtMKsLFZ0ocKinpJSsuR3zFZhjYr2QHNDQ7liGT0Ij0LHwyPMNQGe +EYzSDFH/QWZqQMNiPUbXdpwE7IoAzqanU+rHuQyUip6x6D5F082Xezt8TDgi9KWB +eqsZd9sjfxqGz9TtIb576VHSb5G0YoSbhPwgqkNvs+OjmP6p4V4/5VXMKSmpl6tR +D4RqZ2/G5ePmPAOIRgQTEQIABgUCVg17agAKCRCI889MItf27G0/AKCpc5GuJl41 +/Q9p6Hu2D6eEnN9MwACfYY9bbZd1i1ex732y7Kw5E7ga3i6JAhwEEAECAAYFAlnl +Hi8ACgkQtbuVrGXEaKNedQ//V3f//4diPhoz/ObLKZimvl8ai7pOAML4ZIYFbOEs +9M3EeaE0BAJIvNZCb8lx6bapF+kBz+S6gdMiEaucAeEZHtFL2yyoHU+l+N83+DZ7 +pi+LkmmE63vdMsoiwQj8H16iWmUd0UW2Yb6B3g19HlWDIXIxp36l2lv1HHwEoBla +V/xAsAVldZ0zt0YyZNdCcyBw+Dk4k+RxjlKvbjbtPBrKhse9FZ7k+llaT/nNn/OC +27YNXa9w/RE4zPvfBEy6gn8+ZQUUVzx0TlPL1AIb8qYRQ37U0XhZLiqX2WIaAxKH +29wIMEAtfPLd/Zvy9oGfwfV0c7ftVsIHlx5yDSC8bEGjHuzUWJ+KJEPecj75FdJ9 +WqgrN4JoN7Mp3JlPC3NhGW05T21DDqwHFPBJtY26rKQ0KNjflpctibYCWyzyVZdk +C5iVgT9E6ExKm1wO2dz/0YZrSIeG9dlqyVWwKIY8bAypi7iTKYsox0dAb/C++FTi +kaCajYqr68g6DD8sU0mVcj7jiwcbld3d8RKZdqivHa2HJ3xpsy7PJwEWQo9Kjbyx +p/YY0JRHtVFzXCEHl6wtqCxPmmba7OjPlnO2LSDX9CdgYAY7vf3WiCxd/svruKN2 +gcKrffDc9q+GPG7GYz1j+qLPwS1K6AmgjNmsAD2LcGwQxknf0LwHyq3WCGVgAbE7 +MeOJAhwEEAECAAYFAlsVt20ACgkQN4tEabQASLImmxAAm68HGu+GSvIcdObZGkoT +RGOM2DaoLhVSOTloEk5Tfp4+nj+AhELyiehANUqj+OAVsSHm4V+O5DdHJUa/WDoq +996BH9A7UmqXXFQCsilQlUrDebhioIL8+wImMiMbqM7/UrHBIz5xennP2uYHq7Wu +kXJosXEPaxe4tIAcGGD28WXqUkl9mqV6NNXuN7IirFNEjcmztMHpWasm29eDDTDQ +1EwUFpfa3ZNjqoGfvhur/7IhRWYPsw9LdnJLsrG/mZ0rVSFwfHdHRtwBeSjKQQC3 +EbyQo2tFTSR+UCOu6GNB5NjmikSM4ep+uSEhmTCr4QjxBnRBytO0E3RhJQEewqdj +1rOcU65P0hqTppqO3SEI+qutaeUr9rE+2JGVxPFzCWc61bpucsusgpobjpZhv3OM +ji4s+zI+UAyXeF59IvJppyHcQGx5x9GRvW0F2a308R8gTQJzl7Y84XOfByaT2Uhy +hIwUPXqO2p6jTyGuzBCUT4TLZjYaZSyg9HJRonLmfQC9xSpvLENaerKZWrsxfqjz +iF/6/APWrhsHV01HbB6vgURZa0i95TmxBlIssYG3Idq/NuT3nR1Dr4QQMhTnZK4d +3ixAgSboRfZOLYcjm2LUJ9CJDs3qd/yKWlGez1UkLC2uzA7hW5OiSY34MVAbFk04 +2YcizMAfjP86noolMrNHwuKJAhwEEAEKAAYFAlkJA/wACgkQeENO9GDWkUtUUw// +XEBA8+8KvHRKzQFRUmYdoRJVCc4iTPgj4c81SIJyQu0RXEg+7CB290BcmqeRMlZ4 +yOALVOvmh+bD/uHjWAkNLCL8yQV2rhMAR8s0LI1Iate/0zyUX3o6n/EObkF+B8SV +ZDAd0oZakRe9CtyQamHIjfLmv6BDK2arsqIvfk6Z8yWiZwMBt2JiWIIQxWpwcGse +pyrGuUyvotrKgN4SEsKPdXSTk/bIjYRMZHJuRLyBR8G8pMaqEt1LAihNx1W3IVFe +2BSUpDgjczMMUeB42LnRBB7y649KOtYxH+SHzNmdAntFFIJzgnUOMdZ/BK/2Oq9T +KFdBXl9QUwq0g+3ZJOLDGyyq7828rqd5uY86XQ/5VD4EN11mLMlmXWAsZ5bkmMTc +EAS/8LjHp+XpE1HFFnXQEizCmiCIYhB/MDHq31aK8nxQKmb1emjkQtfLJLs5TfnP +FtHRyXRdJM/49x0JQ1KddAfBj+vAPoAQxTFoutHBgLEvNMWOK/ANkpK8RdApaOQV +BKCmQMFsQSr18pVdnwQoS2eckj4tmp6EMJEY1xtUXyjhEX9UNqQBgC4y061EbbdC +i7py3x5l8EiLKJR90HxIGZjh0ntc67cQ7GoBq8FdWanuFuu8/fuOEil8dgpenD/P +0eT8v0XOvnIH8rtq9XGGIdG68LNPixO2pZmflD15J3GJAjMEEAEIAB0WIQQc7zP6 +YYABF72y4ODVHqjwDuebKAUCWyJUDgAKCRDVHqjwDuebKA91EACsbijV7UvOa1qS +uyKEqyOLJiDDfC7nQquwu/w6fVFyPnd9tKqkJxIey85ypzkl5IcAnrPd80UQUkR5 +n0sqFYEz9OINn/lfYEW2uGi07pK+9/EMgtSXE/hZLlIhKDv6sipSnH1NuZru0Dcp +IYxwOYQ1Ean/f1nSfBWD4GSkDbqBjXDhJh3oI1IrK9QI8EU2Wy80zvge+Ut0TY0M +bSyPgudQ0PYy+l9gPYCzL/JY5lh8adkXbcXDgDVB3gZ7v8sx1s675J2/RrToL5a/ +EyCm6DTxtzrNnTawXS0QmZu1HudlCrxhlQEfXKjsbun53xwH50vgQS88TtJpzx6u +G06J5nUCKFxaMHb3RPS9uNNMdAB3mupMQf9WAY/Fn2fe2/a1J+pfQODH4U7dkN3i +jqEkMSbxjP9IlX1L2hppLqbNp/w8DJn0Q5XMYCoiKETgH7KnLJF/m2iViuqQZ0eP +GbTQRhWOZay/xxmAwrnBEAGiybfWvjopADk1AxASo6my6GWLL7Pct2qih3kjQm2i +Vr0PiVHmiSwcuP2cYgSgK5YOkaWKvLD5G6XFdvp6Ut/haS8qW/Qf9GBdGXstgokM +kcBn63yb892TZIshcanXyz6LRZ1kEcjsjlKZIAjFFxyzQksQ16b7L+kGhmJMYN2S +i5dtLeQDlJQ18AKJKxM05Xr5iTBD2okCOQQTAQoAIxYhBDgjfuQlBQKFB321etIs ++EbbsWKgBQJb0vZ+BYMHhh+AAAoJENIs+EbbsWKgKaQP/24voEwiMb1OFoABShaE +4uzxDnEZdrbN5a7/Lso9SJ4J+56Bu5vbyCadQXuQN5RmgHsa71e6x7/4/FoorgUI +ATUWYnEMUhgMO2cYH9JnDrgQyTW2iVvFHh45383TYq5wshJBT0yr7glEJQ87VZ8Q +c0Gnlc9+g9ZnwZjauex5AsyoJB57YHlgxch/4EbXY21oEbdTwQknUnJcQkeT57T8 +QHPKDsxQEHpIq0viC2vO5KE/QLtWEbdMGfnDJPIw/sWv3xhdPLouEKFRHkG0nx+B +lHqNs7F9Bwf3FMOBpL5FAMxIkjVx+crmjYKSfxARU784589f1SXHa0mahNZgByrc +mLrPXFN0HydNc9HkJDCvol1Qfo/dxk79mZpSKgkbsmpXETmG1lp4InSuBtfMugyV +fyX/CCVcAXHArAqKgCkMqSDFgdF7ENm9ekg0tuBAClyYizXck/Vc35Z0h15figKM +YsnT3ZJtEJXh9gaHO3r57GUpZAWPAiKYRGWMHxGmt7WBerqp+9AKRap0SzllhQI0 +BCTbqcMJrqFnO4DUp8VSHheJ8LIXv9iV+tHlzPpmtq2Zp6GOcXTA6VyAz15Xjv0c +x9QfCG4F47uUVKe0tiICcNWmMWnWo8FgEFAN8++BrQ2srs1P3b64YcsIuuY84jxK +f7+gfMgWr5zMLgDBZjxflmaItCZPd2VuIE8nTWFsbGV5IDxvd2VuLm9tYWxsZXlA +Z21haWwuY29tPokCHAQQAQIABgUCWxW3bQAKCRA3i0RptABIso9SD/9PRsfL/aZP +umV2aDMhnsDtWWmWZOZBdOYrmRWwybjiO1kT7AkCoHAry/SRQAH2JIr1P+Xl1jzn +WXJRSIXYHbkOKuAOM8/7HsMpEFZqhGqJZ2AOvMC+m6pAohn0LTwh6pv1rQ1NFLxW +8tdPIYL5UenUL4z13SjUYE+9+XqDBNqVwPTQE29N8xRDchllcJ3zluIePkESIttA +IjM5XAt+KGpxGSH5T3rrYkFHOnK7EFzckP6KYt1KQv4ifrmkVxGJ+IjpMIoFZA6H +ORt1u8d8TrDJ6WZTrlIShfeGTwcO8De/oWZyebMnk9g2zLRBN0RW5MNpvQ7a+CpH +mnHQUOOXJ61c0FbgPdrIZVo/qGwRm49KVW7lJUV5Wue02mYyy8/qIwpCnbuKt0xD +9jEuiwu57SWe1gdEZDFjF9/d6Wwh7kUrS2WuN8pR7X0AhJ3h7sMSYvmbSypHZzE3 +4YcxW7M+ailxRFp7cXs6s2qUC+1RZ1kTwopd4dTMBgNUyS0n8a+xDTOM6l7oyWB4 +xtV37ArjGqrywfPPuMHLdr3oOanpC8S7c4IObj2H1Erw1bNRe+UGd76unkdzrKj9 +mTrHl8+HNTeFA/j4597cl9MM78VtAYwRLs1w/h8nppK1AM9Sjc5lRIW7PBJLHNQ0 +A8rYcI5+/D63DVAwCsnQ02kSKyHlQFKH4okCHAQQAQoABgUCWQkKIQAKCRB4Q070 +YNaRS66HD/9tbH+ZWUATe/ZTI8kxOyFKxfaIyY+6rM/dhspTvhsdNupbb9pUD8Nx +MFPKBmeR5v+LNb+yRRK8NySBiANtEHHAIgZPkrKdKZBsj5x2DGWBVKlpgIprj4Wh +IsvrcBjfBzZoZn6sPyIuG4HoagJhVKxjkggN0FP4aaA1muolHRzvTa2pIai22lwq +IPxysSDl3+XESI+l62gDSkWN+JvyOQVsXw0AmT1kDIka9aeejGfvN3vjm6I5+iEK +XG26lILGzDpwc8QBTtkoXNVdVuP5flYSRe/fPE7+SGGVEjgr8mBBzV6a14lDdKBX +AHCmRQnCItCoLDTbdz5msuP+S7k0nhcKba7R5+RyINv359Ib7RSsLS3z3IrSQYsK +xWdBdwL1xsBF4QCpQo6W4tBE2cc4VluM3KE4SrwIoKH9sv3VLkct13exP6i19k02 +ZNwMTbwRe5yFlfBXL46w7B0bsM4wdEgqUwQaY7arpUUOK0dFUhNHrdH2FCBLIyEl +dBPG8RtNNkjMdwIHe40aV+KBlKihd9DC/s39WYsKzLu77SlmBaSlorEyHqDHG9+e +2FHiTX6ml0JJP5Pwtxz+IZ9T84bNTZD+DFyk9xGhTxmm5TTjli8h6sEsiNt4fFX5 +9+/ZW5EYmnxi4MUDm+09O6H/Oxb4XYvFRfV0hQeyBTy4Qa5GnA6yCYkCMwQQAQgA +HRYhBBzvM/phgAEXvbLg4NUeqPAO55soBQJbIlQOAAoJENUeqPAO55so38IQALr8 +tfluhqbDkq9amm3UVK7nY/iVYrrVnvy2j3aoRaWt0he0Y/VjzdJdA2whyCaCsb8h +6pFTEnP15f4FS0SxP8FR/eNVJX5I3p6NmlXd6cyfD28NBmrke4WeFxPNiIT24pBF +BNN3tyz0Pchitjt8EZ+SdiqZAOKwZUs4tYXVk3ZZKFNSRvuKjK5NlbFHroMUuIs1 +xEL3F/eFfM9HViZd1hWnFRzQftZODp0JQZsFQND2DA9p9B6FcvuA9XMty9Tbix6C +hLBnXhYGtr/SawLRh4FnfTK8Zp32mMiSR19F8CspKvKMLCsG1ptNE615AsZJjNVn +qTWVQtPf9vT/f3YhNPWUm0CgZ219fuyT3/CKseP0PNWsGgcuSIfdtPFsDMAf4DS1 +hAjhXjfa3HrySdRBGeiMo+6Nk8eH3+a/y5XU5zOYtEX093CD9x79/v+5bg/4fNrt +wb/7hFvbS5v4jWnxH5/7mDiO6sXojmrxM66DpsJhiYxGEpp1yVHKueHJ1n9KKwT8 +LXyHjU7xPPMEUT6Mnrybv9jorNXXJ/2Iuzj5ogAQ8ZfRLrvrnYWl/ExWwZ2WBCdo +fJ5BX+PnaSqhmMRmzkKakAwGCpHWshJJ+UK8OP+vZ8rX9S6qSvEEU+kvOY4UU1h5 +5N3mi7htIWg88agOOVbH1ViddRMtBTA5fBk4O1HaiQI3BBMBCgAhBQJZCP6aAhsD +BQsJCAcDBRUKCQgLBRYCAwEAAh4BAheAAAoJEBIJ5/E9DJK5zjAP/2OMy7w5Txwj +HFV/RmUP1vNVK7aq3eKktyJrZcfzxfzGHfnjrp0dGFOHvkl6YsRh8d0xdTcLu1Rd +7FdoI3h206DiczS2+ZAbmbheWEsHwxGYtLxD3BEeuKAm5qXNC0Rf7gu7bce8Nwzn +y/yLN30HMqWPB6I6YpNaX9Cf1yS53H6B+PUM0ZcAhVyYu2hz068sTrf8DKlwUys4 +iaAGYfhd3Azxj6OvI2QWQUYzhXoOK9y1WHow5KMh8HYrxDDQMF7JcOdryj5BEZqf +UCbgCMprzAG4xub4PJnBLNZ9iQTCx9WDSVT/E5zZt2KQr016O6w22vrMIdEm9jDN +jZuVGla6oV3iVLtiRegkqdvMsLnElUh+xHA3Qx8SGtzs8evCXecfmFale26q+6h4 +VyNbhCyDmNsIYuJqqDQXrtUonuY/9Dc0jUiX4OTQ4AaLYMJXA6FmYbmpt9BvvbML +GNBz1TRi8E9UAAzGvsaN4rW5V5qfzSIk3NDE85UzVpFFQbqYMEN7jyGfwI8YZ7Sa +JXngNA3cy6CiQN/BcLzWZ7DSGS7ASgGIFxyc+Uybwnas/9gM4Ue0yaU1vND7zDf2 +QAlGKBjl3a2M8geuK3i33WYM6c5k7FCCHv4M72lp9B6aQ02PC9ETjrSAb8suHKVJ +JLNhO2myLs+yWv5EhnWJDSxivzBg0LwHiQI5BBMBCgAjFiEEOCN+5CUFAoUHfbV6 +0iz4RtuxYqAFAlvS9n4FgweGH4AACgkQ0iz4RtuxYqBTgBAAsybt4ssG+ULY0Fhh +/tiDQyyw4UQ+A+ajBk1iNwhN6Qu34HE98xdcCZBWtCQMmvzlFNDltyqJl5/l05ar +ijf+UcyMqtlAbdSabIxojAcmFLTmOfiGZhlBRX0ATaoHtl+/qsqA51LbEUM+Z8JI +kWmvOm8+THHMUeRVp1PjMYWLZCrOOJWTuVvGJ8fLP6vd+o6MZEeVKpmHRm0t6B/w +62lbhK7417CVB0bUUp9AlCUHQOxH9EbAH2mFviRCVZ8Nxi6CF2fzlx49jU8ZhUH+ +lUYncGU5woCiuvks7kfuoEk+b5rIjuzlUeZA7NYNJaWCFnlKAf5PLDXObHfF7Wyq +hhufBi3Lrij6qc65Fu7jY5MO6624AiB2fZlqcvEsRV1Tu+MngVmM8EEGB1O7Qv6z +1z1eeiM2hutxPVRc82R2b+atMICwLa3wR9q27+be1vAw03qwy6ZBO4jV7bFwDOAa +GXbpq5xrJvqMQan2BNpTrd8pJ+uWRIvyiKD6PDgA52u/1C5DNg3OSBNG5iIyjgla +JJ2HoCRI7U4yUy0+hlSgw3uPBfNoK1XJWmYtpZ+Zz5nL3ZbTNg5uvmVTa10S1DvD +/N67xApgYbjbOELm79UJm+vzNgiKYDh2usZ5zTTPdsyRO5REC1478vUz8PjY82Ye +KJBwNQ5W/pvTJqEo0itCZcDMc8nR/wAALxT/AAAvDwEQAAEBAAAAAAAAAAAAAAAA +/9j/4AAQSkZJRgABAQABLAEsAAD/4QMERXhpZgAATU0AKgAAAAgACgEGAAMAAAAB +AAIAAAEPAAIAAAAGAAAAhgEQAAIAAAAVAAAAjAESAAMAAAABAAEAAAEaAAUAAAAB +AAAAogEbAAUAAAABAAAAqgEoAAMAAAABAAIAAAExAAIAAAAfAAAAsgEyAAIAAAAU +AAAA0odpAAQAAAABAAAA5gAAAABDYW5vbgBDYW5vbiBFT1MgNUQgTWFyayBJSQAA +AAABLAAAAAEAAAEsAAAAAUFkb2JlIFBob3Rvc2hvcCBDQyAoTWFjaW50b3NoKQAA +MjAxNDoxMDoyNyAxMDowNjoyMgAAHYKaAAUAAAABAAACSIKdAAUAAAABAAACUIgi +AAMAAAABAAEAAIgnAAMAAAABAyAAAJAAAAcAAAAEMDIzMJADAAIAAAAUAAACWJAE +AAIAAAAUAAACbJIBAAoAAAABAAACgJICAAUAAAABAAACiJIEAAoAAAABAAACkJIF +AAUAAAABAAACmJIGAAUAAAABAAACoJIHAAMAAAABAAUAAJIJAAMAAAABABAAAJIK +AAUAAAABAAACqJKRAAIAAAADMDEAAJKSAAIAAAADMDEAAKABAAMAAAABAAEAAKAC +AAQAAAABAAAA+qADAAQAAAABAAAA+qIOAAUAAAABAAACsKIPAAUAAAABAAACuKIQ +AAMAAAABAAIAAKQBAAMAAAABAAAAAKQCAAMAAAABAAEAAKQDAAMAAAABAAEAAKQG +AAMAAAABAAAAAKQyAAUAAAAEAAACwKQ0AAIAAAAcAAAC4AAAAAAAAAABAAAAfQAA +AAkAAAACMjAxMjowOToyNSAxMjoyNzo0NQAyMDEyOjA5OjI1IDEyOjI3OjQ1AAAA +GKcAAAOKAAALRgAAApkAAAAAAAAAAQAAAAMAAAABAAABAwAAAGQAAACRAAAAAQAB +8DAAAAAhAAjTZQAAAJQAAABGAAAAAQAAAMgAAAABAAAAAAAAAAEAAAAAAAAAAUVG +NzAtMjAwbW0gZi8yLjhMIElTIElJIFVTTQD/4QsWaHR0cDovL25zLmFkb2JlLmNv +bS94YXAvMS4wLwA8P3hwYWNrZXQgYmVnaW49Iu+7vyIgaWQ9Ilc1TTBNcENlaGlI +enJlU3pOVGN6a2M5ZCI/PiA8eDp4bXBtZXRhIHhtbG5zOng9ImFkb2JlOm5zOm1l +dGEvIiB4OnhtcHRrPSJYTVAgQ29yZSA1LjQuMCI+IDxyZGY6UkRGIHhtbG5zOnJk +Zj0iaHR0cDovL3d3dy53My5vcmcvMTk5OS8wMi8yMi1yZGYtc3ludGF4LW5zIyI+ +IDxyZGY6RGVzY3JpcHRpb24gcmRmOmFib3V0PSIiIHhtbG5zOmF1eD0iaHR0cDov +L25zLmFkb2JlLmNvbS9leGlmLzEuMC9hdXgvIiB4bWxuczp4bXA9Imh0dHA6Ly9u +cy5hZG9iZS5jb20veGFwLzEuMC8iIHhtbG5zOnBob3Rvc2hvcD0iaHR0cDovL25z +LmFkb2JlLmNvbS9waG90b3Nob3AvMS4wLyIgYXV4OkxlbnNJRD0iMjUxIiBhdXg6 +TGVuc0luZm89IjcwLzEgMjAwLzEgMC8wIDAvMCIgYXV4OkltYWdlTnVtYmVyPSIw +IiBhdXg6TGVucz0iRUY3MC0yMDBtbSBmLzIuOEwgSVMgSUkgVVNNIiBhdXg6Rmxh +c2hDb21wZW5zYXRpb249IjAvMSIgYXV4OkZpcm13YXJlPSIyLjEuMiIgYXV4OlNl +cmlhbE51bWJlcj0iMzIwMjEzMTgxIiB4bXA6Q3JlYXRlRGF0ZT0iMjAxMi0wOS0y +NVQxMjoyNzo0NS4wMSIgeG1wOk1vZGlmeURhdGU9IjIwMTQtMTAtMjdUMTA6MDY6 +MjIiIHhtcDpDcmVhdG9yVG9vbD0iQWRvYmUgUGhvdG9zaG9wIENDIChNYWNpbnRv +c2gpIiBwaG90b3Nob3A6RGF0ZUNyZWF0ZWQ9IjIwMTItMDktMjVUMTI6Mjc6NDUu +MDEiLz4gPC9yZGY6UkRGPiA8L3g6eG1wbWV0YT4gICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgICA8P3hwYWNrZXQgZW5kPSJ3Ij8+AP/tAHhQaG90b3Nob3Ag +My4wADhCSU0EBAAAAAAAPxwBWgADGyVHHAIAAAIAAhwCPwAGMTIyNzQ1HAI+AAgy +MDEyMDkyNRwCNwAIMjAxMjA5MjUcAjwABjEyMjc0NQA4QklNBCUAAAAAABB4Tw8F +b+k8CItiwUB0dn7P/8AAEQgA+gD6AwEiAAIRAQMRAf/EAB8AAAEFAQEBAQEBAAAA +AAAAAAABAgMEBQYHCAkKC//EALUQAAIBAwMCBAMFBQQEAAABfQECAwAEEQUSITFB +BhNRYQcicRQygZGhCCNCscEVUtHwJDNicoIJChYXGBkaJSYnKCkqNDU2Nzg5OkNE +RUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6g4SFhoeIiYqSk5SVlpeYmZqi +o6Slpqeoqaqys7S1tre4ubrCw8TFxsfIycrS09TV1tfY2drh4uPk5ebn6Onq8fLz +9PX29/j5+v/EAB8BAAMBAQEBAQEBAQEAAAAAAAABAgMEBQYHCAkKC//EALURAAIB +AgQEAwQHBQQEAAECdwABAgMRBAUhMQYSQVEHYXETIjKBCBRCkaGxwQkjM1LwFWJy +0QoWJDThJfEXGBkaJicoKSo1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpz +dHV2d3h5eoKDhIWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXG +x8jJytLT1NXW19jZ2uLj5OXm5+jp6vLz9PX29/j5+v/bAEMACgoKCgoKEQoKERgR +EREYIRgYGBghKSEhISEhKTIpKSkpKSkyMjIyMjIyMjs7Ozs7O0VFRUVFTk5OTk5O +Tk5OTv/bAEMBDA0NFBIUIhISIlE3LTdRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFR +UVFRUVFRUVFRUVFRUVFRUVFRUVFRUVFRUf/dAAQAEP/aAAwDAQACEQMRAD8A4XxH +IJdXlYdBxWHWlq+f7Smz/eNZ1ZR2RqxKdSU4VQgr0Xwcv7vPvXnVel+Dl/cg0DR6 +3p5/dAVoZrK09iEINXnkArFz5bicbskZwKTzBVJnJOaYXxXP7dtl+zLTzACoRMRy +Kps3NAf0p8zZXKi95pPWomO7pVYyqoy52gc57VUk1S1j6Nn6U3d7gl2NuMmpw1c5 +HrELH5SfxFXItVtZDtLAEcdc1cXYlxZs7hTCc1AsyMMoQaXfVORNivcgFTXNvG3m +7lrop3G01ktgGuaS1NVsXrGVkGHrX85cVzUMu04NX1fd0Naxn0JcS5O4deKzzCtO +ZmA9apzXYjU+tD7sEc9r6L5e1ec15hKAJmA6A13uqXhYMWrgW5cn3pwHIliFMuel +SxVDcnit4kMxGGZR9a9R0AlY1xXl45mH1r1HRABEtTW2HA7iKUgCrHmms6PoKtDF +cvNYpn//0PO9X/5CU/sxrOrQ1XP9pTg9Q5FZ9ZR2RqApwpBThVCA16j4QX/Rga8u +Nes+E1xaL9KEB6FZnC1bKlqitVAQVc4Fcc4XbuaXsVH2xrlu1c5eawkRKxgE/n+g +qzrWpLChjQjOPyrz64umflCMjrxSUV0NEurN6TWrgn+ED0warPr86jhlz6dK51r8 +R/LKA3rjg/r1rEmu1JLxHj+H0H+fStVEGztp9eluYwpzjuB6g1Re9lY/Jx65zXOp +dztAGiAyOSz8DHrk1ILx8fvJd3soJosFzdS5mP8AD26r/wDrpRJLvViSrA+4rHhu +8HjzD74Aq2dSB4zg9AadgOttNSCMImkJcDqP5V08V6SAshANeYw3MVpmQHfKfurn +oP6Vsw6iUYGR9u4/5xSaTCx3LsW4pmw9xWfaXm8AcFfatpcHmuapFrUEVWjUjpUa +o2QB0rSZRiqyna3tWMZ2Y2rkgjGOaqXVsritDcMcVWmcKhY11XRmeaayhi3Ka4/v +XZa6xYkmuPAq4bAyaOqt0eKtp0qjdVvEhmZEMzqPevVNHjPlivMLNd90q+9eyaTb +7YVz6VFYImqmQKl30pjxTdtcMlqO5//R871Y51S5P/TQ1n1Yu5POu5Zf7zsf1qvW +S2NXuKKcKQUopiA16/4XXFmv0ryCvZfDa4s1+lNAd5bMBHk1iahrIyYbc8dC3r9K +rapqBt4RbRE73HOOwrjlZpHOeEHU929v8a5HubRj1HXU0l1Jx93qDWRLPDbnCDJ9 +uv6VoX0ywxGNT87HBI7ewrnZPMmX5MDnbx6VUTQsPOJ1KsFY+meR+OKzlsnLEYyG +6+3vWnbWIGN1bMVsNuDwKrmLVM5o2TBQOoXkZ6U5bd8fMD/L+QrsktFIzjipvsaE +D5anmK9mjhmth/Ep+vWkERTlVK+4GTXcGwjbPHWqkmlBvunFCYnTOThKW5LH73qf +51YjvdzFwu4jABb1q9daVKoJCj/P0rAmtplOB8uKpambTR1VlqkTy8/JzwQP8K9B +sLreoV+Qe4714Zue3bBKg+hOTXXaJrogdYZc4PoePyPIp2sS9T1Z9yHk8HpSLtxm +kt5UuoNqMGGMqarBtuVPHtXBWo8srrYSfRlknHSqdxkDmpA+KrXUmU47VzV+ZR0G +cXrigoTXGAV1WszZBWuYArswl/Z6ky3HqMCs66rTHSsu6Nd8DNkelAfbkJr2rTiP +KFeKab/x9qa9i0yX90AazrSs9QidAcYqPaKjL54pd1c7syrH/9Ly1vvt9TSUrfeP +1NJWZoKKdTRTqAAdRXtXh4Ys1z6V4svLj6ivZdNmW10wSd8YA9SaL2Q0rlTVnc3D +sDgZxn2FYjXUUJM2cnGcn9MCtSfDJ5ZOWPU+561iX0SvGQo6nH4VzI6DPjmN2CD0 +PIP1J5rRhtsKMCnabZAA4Ht+VdClqq/eob7G9OOl2UYLchfcVdii+pPvVnYM8dBU +ijPJqbGtxY4/XqathBmmoO+KkX3qiGxfKDAU4w5qVFAOamAz707E3KgtwwwcViah +owlBeM4b1rqdmaYUyNr96YrniV/pstvPsY4z3P8AWs63uLiGTbICR0INex6xpaXV +uxA+YdK8znt2RXQgb1HGe/8A9cVSfRmcodUek+FbtpQEU5DDI+tdPqC8CeL2zXnH +he4NvLkHjhx/X8x+ua9NmkGzzUGUI5Ht3/Kk4qUXFmUtGmZAmO3NQzOdmalZAHI7 +UyZQFrh5ejKOC1kHfn1rEArf1oZINYQFdUNiWO/hrIuutbB+7WNd9TXRAzkGljNy +K9Z08EIK8r0hc3Ga9WsM7BXPiNxI241zU+wU2AVbxXJzGiR//9PyzuaWkFLWZoKK +WkFLQBJEMyqPcV6Nc3MgWGwgGMAZJrgNPG69hA/vivQtnn3MshBIGOQcf5FZzfQ0 +guo58CMkkEk9Qc4rPuFOVU9+QK3Y4EyWfgJyfb2rFbM135j8e3pWVjVG1ZRBIwTV +7OeKgh4QCpRjac1J0oDgcH61Jxmmbe1OUn8qoZMMjpUyYxkdKhU4681Mh5x0piZa +BwOanBAFV1yakBxxVGdicbcZp+3nJqIPjpUoPHFMljXAIxivOfEunGKQzRDhga9J +9qytVsxcWzLjkcik0NPoea+HpGluFQnHPNewaejrB5EvOMkH+n5V45Yq1lqhP8PU +/wCfzr2GxYy2wIbLAbcj26GrhuY1NEUrtGjmJUZVuQfaqj5PWta+H7gMSPlrnJ59 +vA61xVo8sgi7o53XNu0Aetc6BWpqUod9oOeeazBW0NhMVvu1h3R5NbUh+WsK6PNd +EDORe0Yfv816vpw+UV5Tow/eV6xpo+QVzYjcSNdCVNWfMqNFBqx5Yriehqj/1PLB +S0gpazNBRS0lLQBo6U2y9R+4OB+Pf8q9MeRYxuHAHT6+przHTQWvY0HVmxXdXjl3 +2FtsaDLfhWVTdGsNiw0/7koO/qf1NUrXBfKcnuazNSvDsW3i43jLY9Ow/wAa2tKh +KRKW9P1rN6I3pq7NaMbRtPerA4HHSos54AxikaTAxn3qDYnXn8KcAuTzVUSKBy2K +nQq+VB57U1ILlg9AKmQYXJqoJowQknBI/WpDMhTA7datMPIvxtxk07d6VQhkBYDq +BV5cdPWqQmrEygtVle1VUcDHtU4Yg5NUkZsmTGatyW6ypx1qsmG5FaSDA+laRVzC +bseX6tp6W+oq+OGOOK6bR5NitAehwykflS63Asm5j/Cc1JZCP7Oj4wV+U/jUxVmO +bujRkjJifPoTivP7stzivQzLi3dx823IPrXn124JOP1rnxCV0RE5ef79Qip7jiSo +BVR2GMlPy1g3J5rcm+7WDcH5q3gRI2tDTL5969SsMhRXm3h9ckV6jaJhBXHX1kCR +rwjJrQ2iqEIIq+DXFLc1R//V8tFFIKWszQWlpKKANvQdn9oKSQG7Z/WuoA864kZx +wCAB9PWuV0CNZNUhDE4zzj0Ayf5V19xPb3Jee3+Qnhl7fpWFR2Z0UoNxbOanJlus +j5mZsAf57V3VjbyCJIy8e9uMBs/0riltBJIzN0Xj8TXUw6fEYVKjkipky4J9Bk2r +WttcS27kloThmCkjPt61fSzkkw08jAnnauBj8etY1zYxKxJQbiQS3eugeVo5Gz2q +opPUqXN1GmxRQcSOPxrInimjxsmPJ77c/wAq1TbzzKXk5BHGK59tOlW4G9Q8ZUjG +T1yOcDrj34rXkizJza2Q12viSRIr49Rj9RU8dzcltsqlSeh6g/jUEcflzMqggZ/z +xUt7d+TB9nQjzGIOPT3qHFGkZs6bTwz4z1NWbyX7MdzsFA65PFc7psGpuFdLtkJP +dVI/lWhKJWv/AC7sqxUMygDvwAefbNJI0k7aleXWE6KGYZ6gEj+VWLfV/Z/++Sax +NQeQyMq4wo9aj05rl5WSIoWDBdp78Z/Kq9m90ZOqlozsYNUw24h8e6MB9c4rpbK/ +guhtjdGYdQpBrm9C1mG3na2vgYmbAHGRmtbXruyGnS3KsmYyCGGM5z2q4q3Uym7u +1iHXD5cDy9cDp/Ssrw/eJPZvAxyycc9dueD+FY2qeK7J7cabc7/MkRWSQAEEP06c +5/CpPDsb2OqG0uHVyeCVyBg55waOoN3VjtUykTxS8kj88en4frXAXzr5r7emTXWa +nOYoUWPj5j/LGK4m5XOa4687yURRRiTNucmmUsgw5FNFaoCKY/LWBcH5q3JzxWBN +96t4Gcjr/D64CmvULUZQV5t4fwFWvSLZvlFcVR+8zVLQ10GBU+aqRvmrG4Vztagf +/9bywUtIKKzNB1FJTqANrw+P+Jmjf3Vc/wDjtdPpqmSNyPugAfnXM6AcagPdSv5i +uqjLafpwDHazsx/AHArGotT0ML8DXmRyuqfKvTPet22P7pcfnWNY273+w449fXB5 +NdIsXkr2wvFYtAtLoz54GlZlJ25/OrfnW7tmX5GPUHpn2PQ/zpGQ8EdT1NRuhIwe +9VF2KceY0toCEofpisu5E7nbuOMetM+zxjlVx9Mj+VQGPGQC/X+8a0ciVTsVRCqS +buretZkkP2m5yBznGR0Pr+VaotYycOxbPbca0IrWJOgqblcq6lmxyCFAzipNUtW+ +3214rERlTG2P7xII/lj8afbbVceldEIIbq0eGUblIwf8QexHY1cEKq9DkruzLPvj +GQRS2UflOSy5J9KsstxA5idhKP4WYbSfqRxn8KcfMHzPEc+zA/zxRdk8qEuoI5yg +KAYOcjqPpWnBptuLOQzASHG4bumQarW8meGiYn/gP+NaoF1LEYUURK3BYnc34Dpn +8aqJnU2sZUuk2LaRNN5SlsnY2OQFOFwfwrnl082OqpexH5ZgrMp7FeD+ea7rUY1i +0poo/uqFUD2yO9c8dr2hm/ij4A9if/rUTly6mcVdFa/ujPImPu4/PmsO54BNaqI8 +rZbtVHUFCoQK8zn5p3HbQ5iU5c0yhvvGiu9EFW4PFYUv3q27k8VhyffreBnI7nw+ +mQtejQrtQV594eXhQK9EjU7BXnVX7xtHYnjbmrO4VXVMcinYasHITP/X8sooorM0 +FpaSigDc0Hm9HtXaa1ZzXCR+QM5HArj/AA7n7Xx7V6mpVkz/ABAEfSsqnQ6sPKzK +Gio1vZbZMBkyvHqTmrh5T2qGPCW3y8bmJ/pUsbZAB7Vk2btatjWIXj8ahL5NRzS4 +Jqt5hGcUIpIuO6quRWPPdZbavNSzSEj04rMRWZ9x6VZWxqWeHY7+MVpq8YyoPesE +MyZKnrxVRmuN24yEfSiwjq4ypfg966aynhaNgT1Xn61wVu7t8w6d/rWoY5njEcMz +R9yVHX86qOhE48ysaepRLsynPPFZdrflyYZByOK0I4pNgDMTgd+tc3qQNtcCZeAe +DSkupcbbM7OB0ZeOta9oQ42nrXGWVzuQZ61vWc58zaaqEtTKrDRlrVVUae6OeNy/ +zrGuIo0g+T7rqnHuuc1u6ij3FoyIMklT+RzWNqOI2WH+6o/WssS7QbM4u0fMpQKM +GsnVAAh+tXVlKHIrJ1GbeledRjrcTehzDfeNNoJ5NJmvTRkUrk8ViHl62Lk8VkLz +KB71vHYzZ6H4eGMV6LGPlFcX4ftSEVjXeJGcCvLnK8ma20HgcUu2pFU96k21lJXG +f//Q8sopKKzNBaKSloA6Hw7/AMfWa7KbUPsN48Nw21J1yGPQEcfka5Hw2u64J966 +DXmheUQOoY4HJ7VlUNaTs7o3reUS2iP7t/OrY+4T7CsvT4Ps2mwxL0wT+BOa0cny +sisGdt76lN1DGojExOB+lWW5OQOlWoEDZFNDuYEwVfvH8KagU8DrUt9aB5nVvwrm +LmPVbOQNDKWhJ5yAStaolvqdP5Q79KkihVzyKqactxcRBzMCxQMOB17itM6ZqXmA +QSqcrnkfpSBTj3JxaqEyDjHatO3jIwwHWqNvaa2z+TIsS992SRj6YrVTTbxVO+4A +IfHC8YqhSnHa5YWPFY+pwRSp83WsPWbzXrC/S0spUuGfkrt+6D0yQeK0Ws724gVt +Qky2Pux8KD/M0Nij3uU7VGgk8rOQehrprUMCDWFp0TspY846E10UIGQx7YqFuXJ6 +G7DyFB71yuqMWu5D2BwPwroGuPIZFxnIJrCmQuSx6k5rnxtRKKitzlS1uYbNjNYl +85IxXSTQcZrl78bSRXPh3diZjUZpuaM8V6JJQujwazrcZuFHvV25PWq1gu68Qe9b +LYze57ZocIFutdSorn9GUiFc+ldAxwK8xo2uOB5p3FQhqfmpTsB//9HyuiiiszQK +WkpaAOr8MD99n3rq9Z01p8XkQyV+8Pp3rl/DA+cn3r02EAxHPesquxcGZ0ibYkQf +wqB+lNhYFCvpSyvncPQkflVFJQkmOlYHeloSyHBzVmzl/eBTVCc55FQRzFG96pAz +W1NBuWVevesd8Nz69q0HlEi+vFUCO1VcIlRYUUlo2aJiMblOD+uR+lW7RNVtpBND +dmYAbcSgNgfhjmq8vSlhl2rwc1SZbhGW5vrqWph/mKcYH3P67qbCuqvLJKbl9jsT +5YxtGfTjP61nibzDyTmtu2dmwpbI6CqJdOK1sS2toqt5h5Pc1Zn5QgelSLhRUMoL +AmkzNu7KNsqIgFacHJGKzV+8BWtAvlp5h6npUrTVhORJKdzn0HFV2ApXOOageYYr +yKusnIxKs/CmuI1I/OxrrLiXIIrjNQbk1vh46kyMnNBPFNzSE8V6BBnXJpmmf8fq +H3ouD1punZ+1oR61s/hZn1PedLYeUuPStdjkVgaQf3S/Stxs15V7nQKvWpqhTNS0 +NAf/0vK6KSlrM0ClVWdgiAsxOAAMkn2ApK3tFiMTNeSfKu0qren95vw6fU0AbPhu +CWJisyMjZ6MCp/WvS7dP3WfSuBg1i8I+zqT5Q+6Sckfia2bHVrprRjc/LgcdOfxF +RUjeJcVrYkkYLcup6NyP5VTk+970k8wdvMXt/KmNIHOc1zHo9B27K8nmoGzndUoI +HBpj5pokmjY4z1qcIJeF6ms9HxxV2OXYM0wQjwOvBHtUBtjnIHP861DMHXHFPiyT +VouxVigc9BWzaxFRyKr7sMF6VejJAx6daomRZ29s1I8Y2EmkjwealnPy7R3p2MG9 +bFGGAM2ccVPM/YdBUq4jiz3PAqtIMJWFaVlyolu7IJJDiqcjHGRUrc8VFtOa4nG4 +jOlOFNcpqB6mutnUDIrkdSGM1dDcmRkg0MeKYDQx4rvRmZtwas6NH5l4BVSc1reH +Fzd59Kuo7QbJW57HpcWyMCt3bxWXYfcFbC14t9bG7I1XmrAiFCAZqeumGq1E2f/T +8qooorM0JYYZLiVYIhlnOB/j+HWu8k+xmwS3jGIkGB6kjv8Aj696zfDNkvk3GpSD +OwBEHqDy358D86guSy3P2u5OIx/yz6ZHof8A63SrhqxMpvcTu/2ZFwq9COFH0q2t +xJDhN5Y45Hr74p93dJc2+2zGcfcYjaB6jH+fWs+zjI/eSnBXqzVUopIIyd7m1Z6i +rKATx92ryyeW3P3W6H0rmLtoTm4tVbHR+fTvirllqCTJ5TnPGK5JQsd9OrfQ6PzA +RnPNL5m4elZaysnU8djU27PIODU2NCctg08y+tVd+4Y70zcBSsSWxOYzkmta1vEY +Yf8ASua57GlVnHSrQ+fudVNLiQbelX47gYDA8+lcpEJ5SBmuhtEZMDPNAORu2+V5 +br6VYPztVWMYGBVuP5UMjdAM1Rg+5FM+X2D+Gq7sMYquZMkk9TUTS54rglPmdwsO +PBpSQKhbJFRZPesJysgIrkZBNcZqhxkV2Fy+ENcRqT7mowt3IiRmChjxSZprn5a9 +RGZmz1v+GAPtRY1z83Wug8NnEp+tOt/DZMPiPZ7RhsFagYYrFsWzGK0N/avIjE6W +W1fBzU3mis8vSbzWuq2FY//U8pq1bWdxdsRAuQnLMeFUe57fzq/Y6PLcL59yTFCO +uBlz7Af410EML3BW3jgWG1i5IkOfxIHBY+pzUGhVt7o2lqiQv55i+TjhNvc++OlW +Z7aAxfbnfhuoPJ/AdqzdQluIWEkM4O0/KgXAx7cd/eqtqHik3zSqsUnJycnB6GqD +Yia9it5NkafK38TH+lR3aTzFZEyxH8I/nitO6stPi6M0ytypXhfzqtbXhdzbInl4 +4AXk/jVxd9GS0SWiR2+JLw8HrGOtUb7EEoaCMJEclcdR7fSrB0/ypDLJJsRuo6tW +xB/Z3lfZ3XeG+6znofYVDXRlJ9UULO68xQkvG4A89xWgMxMC2Svr6VhzyKJRbHar +KeCOMZ7j69/8a2rGc5Ntcja6+v8AnpWMo2OylU5tOpc2CVQVP0NVnEicMMj1rTW1 +2kNFwPTtVgQgjbIP8KzNWjBzUqtjirstjtJKcD0qoqEHaRTFY0LZz2robbnG6suy +gVue9b0ESg8c0Es1YVG0E0t42yHb3PH4U6M9hVG9mV5jEM5Qfn60ql+R2MmZTuVb +NIjgtTZBk8VDkowavPbsNGgOTzQ6grTVZTzTTIDxWctRmfdfdINcRfn95iu2vCNp +rh74/vK6MPGxEykKa54pabJ0ruRkZsvWuh8Pf6z8a52XrXTeG4y0mfenV+Bkx3PW +LIkRjNXN/eq1uAI+Kca8iT5djoZZ35p2arxgk1ZwapTuB//Vy7l2uStvGZNvRVGE +HuT3qrcQxWkJgCsUHzMc55+tQaaPLgluYoCdvygyAsc/jWbLOBKY2PkOwzmNcZz6 +jOMUIssWw0+UtLcR/eG1eCTn2xzkCsiKBhI0d0rQY+ZVIOSp+vXFdIiQpslyWkUZ +Vsc8dSpHf9axb/UVup0SRSvbzM9QfYcfU9T3rWSVtzNXuXrO9s7f/RZY1aNuBv5I +NSXTzEmOCPHoRhQRWSIbe0+ac7m9Tz+QrTtrh76NhCCHXpu7+9TyJfEy+ZvREtrZ +XF7EwmdUYdQAWOPUVUeyg06XyrqXc3VcnGQehx1/ConiuFcSNKw7EA7R/T8akYad +s3PKikc8cnNVzJk2ZdMtvPE0vk+aYxz8oyR+NS2r2urSJaYaJ1U7HI5U56H1U1Vt +dW0q3YOXkbsRtxkUf2noq3O+3aRRnIPp7c1EnzKzLg+V8yOktvtMBa3ukyV43L/P +FakW3+HDA9qdb3Fvq1uDG+JU+6+MZ/8Areo7U6JVdys67HHBx/nmuNpp2Z6UZKSu +hWhRgQo2n2rEuIHifcvP0rphBIv3Tu9KpXMLHPBHrSBlKzlxjdmugtzk4wDiueRC +D9K3rQngDoe9Fwa0L8t1HZW0t5NnbEpY45/AVwtvdWUN29xb3LBpDllkBHXknnit +HxfqcVlbQWDIZDKfMZR6IeP1/lXLnVYvMWN7ILuHB3c10Q0OOo7s7VXR5jBkF8bg +V6MPUf4UyVcVlpqVtbiG7RXRsbTt+b88VofbPtkm4Ko3jKlejfgehrkxOGuuen9w +oT1sxpcpTRITTmBI5pm3mvLRuVbt/lIrjbz/AFldhdDC1x13/rK7qBlMq0yTpT6j +l6V1ozZmyda67w0cMB61yD/errfD2QQadb4BQ3PU4Mhal61VgY+XVpDxzXky1Ogs +RDvVrAqojYFTbqxbC5//1sa1M09rElupVWBZ8sT+GfXNYd5cIbgobdGVeN+Nxz35 +611lkzLZOFJA2v0+tZk8aFCSo6elCdi2jC89/JMNvwM5O3nH1B5/rUE7xXxW3ypc +jgp8vPuD0/A10Vsi/wBnSvgZ5579K4q7AKIx6kdfwq3Zq5OqJ5cPh5eJI/lYN3x0 +/Gq7XlxE2YiY+McdfzqxcjdaRseTgc96rSDNsCfSkle4mym7vKdzksfU802nJ98f +WrV4AGGBjgVIFVcMcNx700giirK8wHPNA1qdP4R1dbS/FpdsfInGzP8Acb+Fh+PB ++tepzxEkFuHXgn1/+t6V4Db8TIR/eH869+g5iGefmYfgDWdVaXOnDSd+UliYlfmq +V8MM1FF1p7/drnOprUpyKpbAPNWLdNzDHbrVKQnNaNr/AKtj7UIp6I8f13UVv9Tk +upM5V2jVPRVOB+fWnyX8yfZ5Yo0Bxj5qi1tV+3McDPnuKuBVFvAQB96upHA+pqf2 +pqhtlbyIWwehU1Yg1e7UjdYw8HkBmH5cda2oSRbDB71BEzfarkZOMf4U7ktGgbqO +9w6RGM9we/4jrTRHzWnp/wA1u27njvVU8FvrXlYymoy511Nqb0sYd6pGa4y7/wBZ +Xa33Q1xV3/rTTw7uKRVqKXpUtQy9K7EZszX612mgJhVNcW33q7nQfupSxD9wKe56 +Hb/cFTg44qvD90VP3rxnI3Y/fin+ZUBptJq4H//ZiQIbBBABAgAGBQJbFbdtAAoJ +EDeLRGm0AEiyrqcP932+0TWbiAiwikNw+493m813H/2MbSUUsH/qLJOPpLYHnIpq +mkrj7cLJ4joeWqnKSU6njxYWlV33mpXu8o4uYDi0u0TApM0jVevqvCpavXlsoPT3 +wfOu27lEZydrZSaPD4nm4PJyHjsf5Wd+8omKDrMqtiYIINWw7rDAG9BhQGFMnQhj +NGbMo5gQCSC9G9y5Rub0wGIDZRYyuNBnfAOfDh872otnnn1dKkzCdm/FYLNx91sK +wpmfz5YsBQ3EnJzAQfh7Er5frAh8pYnP46bJ5SgBKOcvyJSqHSWb7cWnaQQf/4Y5 +22ujSy+nfap2qC6cNNpcF+5eh5775OV/K4plzM5ipPg52JwfN5JaD2LeyyKlpBNz +ipIz7PZZMcMUr1xfiazLeJ9GFKtcTAtO8LhtrXO3NNKYel2V6UBpgu+2H4P5cxMy +swQvA/2U0HhDE/j9faopYcMeNMige0IzaOyGwQCpUTRjARGyJQ/8OiKIjjus9dMx +cnxhDkQ8pf+TnlunD/Pph/lRh3vUJwUklokXBi3SKn9ng4jjZAuvPvwB2mly9H1P +j72nOUlte8n4sATBcSYBlVTlHbuWxyx70V+Ft7MFEGG+oZHBS//N8kEq2dFRijGV +N23vV37V6AGhr1XjUJc3B686xFHuNI8sIgg+DqksXWRAJM4tJTMdbLOdKQWJAhwE +EAEKAAYFAlkJCjkACgkQeENO9GDWkUvtOw//YAozA5KUQ2zzRbKwQBs6sJhJFzSv +s83eOqXq+W9oSCivliOZBHgCjULWtBGjRKdKK7fzCcWJGRYCirvXL1tgw88uljBB +5czfhJPWwJXoIX/WpnCfMTmSGds4DF9yns1Pja5FwlDQVf+rZQmmZEAL7F2mph8Y +0LD2wTyTgPC3THnHNVXw8aQDdIdD60aT6s1+PMZb02ahxIYTaNQg2zK6Gm3orkm7 +PvBDQppHk7do1VSQ/8ECc6kEM2Nye7hqGmtn0B+2Ppae9b7yo1oeKuD9T/2qBFr2 +C0+1y3em813zjqdG0gEs0rk0Kz8pxamBflqfBnrSlfd4K2zNBMlIR2L3UTy3FIbc +OxBE5gi72XEAaftEgtNXHJiOW0HiM2N/cQ3dTnZ698f8QBOSXFRPI4C1VEbp6YnZ +18FnGHCqt8dey8TBRFpY0/8cwFpgetm4VhAhAn11Bns7c31AS81SQIZIwmK2G78w +YudF0BhGRXLp2po/NzHhO6UdfnDNwuN+JyGY5+k1r9lReLIkk9l0YzxcqjQqJ3ny +BSiYusfb0B1yQguk8rjRDDQ6SU9CQjKDpO5sxBn4Pn37lOECHE0bcu9KcqHA3vI6 +SLbPLelAODVfRG+fmQ5k3skUqRoIusJOziKKr51cVE9lKjxT10VpGvQQPknpkiIC +9RXYS2hApjsJYwyJAjMEEAEIAB0WIQQc7zP6YYABF72y4ODVHqjwDuebKAUCWyJU +DgAKCRDVHqjwDuebKAWxD/4gTuK4WA931EJGxOrH4Rsipx4DiZJ1Df9pwPxXJSHn +Oj8feWZQfyVpvKIneOvfxVy2Raf2gmAAv1BnXAxK56X97nGHae/Z3WQiiPbnMvun +ZVb8b+rb4DdRAJ0lKRyOC4XAgsi5nIyCRXzgW4lzRFxTIuuYDtpR4Y0++FXc3WzG +LwTN8HXbcz3oV3KEO0k95ixbTGK2O1ScWRO8HBAZ5deqQQaw6UuoXex4mAGz8mGC +Uj7gNkjLC21hUT2oS4bnofU3HVPrvFdzbAI4y1QMo2xsXOe2oNppWpNvZf60MgzR +gdqvQ0g3/vCMNc6E2AANn8yUN2vSpnxI1pfRWq8pOBLDM2n1Ae/GLnJ4gJTSPyPq +D+7iHxTj05svBJYf7gGk592TMrqyRUfAZ7TgmGfTyLpaNPFhA5sUzvreO8gPcFIa +XjJDvPgarmnEOucQxQ7qSB3Eiq8RQdmSDHgm0o6ZVhhjCW5X/XBDQm/AHyq7ad/3 +P2tm9cNe7ZXEK77J/M1E2Dx9UDSttPXeqaBgIzITNm4P5FKHIhwGbJyPvbS13Gzk +r2Mk9rEqYo599aSOiI+D/EkR/C7Ux6Bij5SxEuXLwLPFvE38/pGkExFdn8LK3W+I +wuYSfGOkZM6k3wYIk7FQPis1TU6N/TVbgtLB05r5691CyNF+CCREQ/MbEKgF6T6J ++okCNwQTAQoAIQUCWQkBDgIbAwULCQgHAwUVCgkICwUWAgMBAAIeAQIXgAAKCRAS +CefxPQySuYF3D/9y/Yc1czg0Z6YOe791BEEUnaw7zdIvGuxcNJj+A2hmlZ++Vp4t +gZ3MMlwJw0JALrK4S8O48OxG2NaB0B1ZPI+eGhXL3O5vdOK1kyiOdzvpIBINueS4 +NEfIbF6SMQwKY/9W+bWyUBZzAhMnV7t+Q99XXVaqflpR3IOhXKP4mCIadTpS24x3 ++tg79jHJBf5h+wx6H8BYOu3CpeaVIysVtoo90UclN1UX9FxCWo/Jrv6+m27gH87u +k0HGQcwFIYuo8dNHV9Gm023Pg7X0AFPFVVogGkoqz3DCkaBejByI3Gi2Rj+BRUMd +7McM6hUoyBFuAUnXoS3abOZD9hnxUJOl13zrnqtSD0uLIZcYoPAZXNkhS3NRF8Cq +Kf65wlo8gzQmM9l2IlA22aESpUKxakENmGJXBDoQJM8Vl65HPhtCZqtZf6uHdwuX +cWHkI8byyrDW05ltJGIb8qM9TP8Mz+2jPVo2GTqRdipXJHE77LgOS5Q7KChmPsZX +2GzF6W5daPutTwLyImh+frzQXS+B77wmUbbwspyeH+dOEOQm6MAzsl9qiep0kbQu +zi9eMrmSM5BDzVVYseKK0mJWrLranHi1pxp5yueogdxGNgLMz/9/ByNciLgPbkO0 +BakVqrx4on58dhAe1t6MyjaUI9ID/MDR5Ab0R/8pcuO2F33TdBuIJJQpvYkCOQQT +AQoAIxYhBDgjfuQlBQKFB321etIs+EbbsWKgBQJb0vZ+BYMHhh+AAAoJENIs+Ebb +sWKg7cYQAISkd7NiqSIKuUxy8sicTM975JdOZ11jV4I+veJviPd9f6zegLnrp9xb +ZIPnpNbRSvR1Wh/HQDsJ0zmNQPAH73EA/EKe326lvx0+px/pxOKm+YZvlsWQ3jQD +iV7REvjFRx6oweuPIg7qI8xiyzcLYxNHVtm5O+PJej1CRpq1OAJwYs5pa8H4stk9 +kFL+n9FG4u7gBTSnE6v9o5xtrPo+Es7LwCoEUO+VV7CAFWujxVAwrMcDNrPoQnZ6 +q05NaRm8HhFHjRzY1Mz3yfOTalh0oTfdfAu1oB7+am22JxkNB4OAZ68oRXXFX34F +R7Jj1OWQ1DAvfHYVfa4hVhyF6z7zpQO1eBXLSyJQdBu0KC8du/WjGKjdFexhP0sV +7c+rAEd3ZSA/viYKFE/FeUVraGQZ/wquX04oJC07ajRnZ7Z8gMKNNouivjlFHLnN +DrJye7vtYCuyGeT6DMCk+uJ4LvcnRMn/f9ot41AhX5ZxghX1cXhi3N6sBzUK8KP0 +Sw9IUQ6e2ygRA2o3BE+gh7JzEfGZoTnbw2p9h3z5bmV/qrgfT3FIgMaFWjPStePH +YDyTa5pIWS5F22DxnZLZDJ7+02qaorS8njRyQFJYs+vYqI/b7F+19MIDnxCB0AQU +T2eorUaA28CUwgSNJNR2jAq1L0oxlTUdRltHVtKoemesGSVQi7sltCVPd2VuIE8n +TWFsbGV5IDxvb21hbGxleUBsaW5rZWRpbi5jb20+iQJOBBMBCgA4FiEER2YLyYvE +M/AeXJBYEgnn8T0MkrkFAl6fNOYCGwMFCwkIBwMFFQoJCAsFFgIDAQACHgECF4AA +CgkQEgnn8T0MkrlVhw/+Oe1agHJZLgZGk8Cc9wF2YLWJxQy7KRjagd2Bo93CmfPG +EwwC4zce06YuwNUHB54VJLQjYtq4yg/E2T2dCmwAvtxSX3wvLIxymHgYNObOzTri +DR2x8VOzWqiiS7BDt26qbAbkYuT+1I9aQuJ4HeEyiiPRS57JbDt/VHihGxLtfLnN +pSva8Hq0oCrjly7eMZ1yjjKo7sJHPw/gFSTxqCWKpKxH/HmeElM45wcTw7/B3Isr +lqq6ry0AyEuZA323OVtIhB0qzy6vMzj4xdFAEBXTFNsc6lesHjtgzr+JZxGJO6UI +20Q8x3uP5DFcPIw/iVhBNWEKCMi77633AOhSgfXOUFGzlXUrMuepTp28cOaylMkj +Enm5RMg+K2PJ2ZiJ+Fyb/3+UaNR6WP8w4sP0EBDQAkRKI8mPx+Pu3L1pJb8gVFd7 +q06tA4rKF4y7RypV0Hh02cQ849spz0bPr2mdhoDZvYqnR4kf3789df6cyF25qDO9 +itMtUjw9ciQtwxYTUTHF6m0pFP2KT8AT8858WQawkYYqkNZ+ZFzrVO2zxDEI7To5 +S/wZjoicxFP5HF4qsDc4NYhKsaEK7Mho31k8s+HW3NruAB7QzgXSznJq4+5RIMAM +qL++/2Ye8nYrQfT4w99+T819QXfLTFKxDL6yY5TcD5SyqkDjqG1je600igjKfuu5 +Ag0ES4N8hgEQAM0SyyTSauPz7iaZVBq3Ju6MPX1FfJzFF2P4qfomy1fm1VI9gH55 +XvyBiGUFOddRY1JevKScdDxFncd5zGI81E2GOadrhgcT62GY9ba0vG74qIn11yJN +WvOfc1mohFoXBagjbmfUFO9xq7CWcJAQgOO67yJe7hnuu4LoDo2l11Yy0gi/x0Pu +N509Xbm9H7sScHcbUyg79IvjJ/HfOY6pPjxbnCu1pMQOwXAq/A5tk10VjsSPoBez +phkO9XzPT2g0KYkZ9iO31dVMvXFta0/5SkrTBAWhBi30oWI0N8VhPUr4fSCHOhbV +HjqtXS+X10qHwfurs0YqQLFuezCB03dwPajb4v5993zwmNXYYDS8/acebozD9WEh +4sxHQCO9YSZYhMzyx9LiS+ASmZPiqbsaan/daf9FxjaeNHQdVpG5ucFgRlGOumvQ +lZxU9HO3wgK+ge5v40bMUlBKN163mtVkeXXkzvoOWD3RsvLt/ysG5xuaueGE61u3 +xMFV1u0QVtYXLulZL0vSnhSuCT0N4I/NHqg4x9Ni9ujZBVSN8k3mhEbL7BPUdIIJ +Fg+8hMkfzBwW2AXWL8XDIpTzfHdJAM6UFbmITzhYJcKRmOuToX6Ki1mSP1TUccsq +e9Di6FPqKzsvN/NtJZQTHe6D7WVs9BHz1NoH/q7VpuSqIcZ/moEFAS/fABEBAAGJ +Ah8EGAECAAkFAkuDfIYCGwwACgkQEgnn8T0Mkrk+phAAmvyaRkDz1j3PZJWZFeiw +49dWJIj0Ve2IXRCny35WLfUxRXpXJysFfzRSdRZdi4OPJrMGzoNq+V/qys0nX4Y0 +hXpB8wFhGCwPGfHUkep2P01REnKB2373/9OVTPDqQiL3DGGoQZARkcPQWxp3KhuL +BnQCTKWOGhnjTfPhq8BK23pifQfAbT6GtCIfqKqNNLoXWqMuTvg0/4pgyNJix672 +6Qmrnq1eZSRq26+ofXWzEZLGOvxYmmpC4jtCds9WCOpV66mxbSJqqRakqylVaRBH +pYNjEfN2fRr8b4HHPp1p2b6tCOAn/GxKKU2zRJT3pkW1oAdR2V584MZ1ObPcw9Sm +BvTnWyyi7uxzG/mApD5cov6IfWa0BMbEyLJE7RqPriiQvcPmwPvrzjNDEKeL2YcW +pZKQhMZ5koXb1Xz+keMohtRdP5vrVPKL1dTdj1eioQz4IgIa1bsEjD7cic31Yw/L +6Boj+5aeIbA4FE9rAJjlrEECIlxpBuase54ElnulayJlXrDkGh6tnaW7wmtRcrIM +cP+VMkwPZOecjr6OYST+iTN/OqEARYsvqDpQMEkCFzZ6rZt0t1SANyjmZQ/rzj+E +XTEqe2DwKp4TFz4RP1+dt0/I4VrC7O0sdQcAVUYRcBUpv5hOGojwyCT0/TgxTHwy +VnWjNggZsC7F4jFQZsZhhBq5Ag0EXp8z5AEQAJeIMGI4kxqWl/IxBADm13BXbjZ7 +avSKbFDetDf1jM9pMoJS4rOtrBZRZXQdOwv5rYaSBC1FjrPJekTfG1WbCW+Ld8M9 +V7DxrkSZJsEreRhRyELFET90Je5PO4N9MegTOqCkyp39ddmNf3Xk4pj9bmE7YODS +XIyU2ArS4yTctpKXz7/WcA1FBFAI/UXqp1SJBbKgnzW4GSm729GD/G/KQNdiYIZ5 +xQtG4Ho5oD9eckBgEIQoCwPqBs31exkwUge67TVhdegCxzqxYmt+p3dhnlCP0J94 +In7MHruhQR3DvfJr1gosnA5GdsPt5pIRnE1X+Y1Cs9/V6B83OqhBTOHoBRhNx0I2 ++T9x87wLPssJzSNFOUBenQpY4Dmj5v+qYjcO4Qh8qXMsjECjh6g8Vz8FFbmklf3o +pGipMXACjzo8HvBGVESVdoMB05hg65bu6ImGk7YD4QCFUD56Zj8IrMYiRjjztsGr +Gb9j2R8WReyo2P7rsj6Q6NmJNYPMEjEvux126EoC8hfLsD01SSIH3atmEQx8KwR/ +Ruof1BXDV0l/+uQp306K56qUbiU38rOX39Hz6KhD0SqmcgEvQPgAntfz9qU5PBSK +CZrYkhKOzZl8/49YUzptZGmN2zABtRJuInFvWblkx8AY9qP0Sh4OWWjEv8SNgI5H +LKAZ//acoDd+4lVvABEBAAGJBHIEGAEKACYWIQRHZgvJi8Qz8B5ckFgSCefxPQyS +uQUCXp8z5AIbAgUJEswDAAJACRASCefxPQySucF0IAQZAQoAHRYhBHXrquz3opf/ +IujBjdGesJ2tHFh3BQJenzPkAAoJENGesJ2tHFh3t5cQAJY1JrT+DpfQ4vp6bSNB +QPkbUnIniBlzZU9HGkwFnbt6/Fr8WDeYy2SJNV9yx0eDv43iVA1iS62cfMkN+Dnl +0kXYBgZGIZGrpOBXOZFamRcAumqpSXT7UKzraefAHVXYmM1t1d9s/6nyO0ZF+88O +tBQ3lfWYO/dWnxHAOW/UdWFCX/P05uMagA4OikrywJQMEuxyQv561Oo9acOIqpGG +UTJirkcLJg1dzHbTLngf6RwRbbdDgOkL7/oB/QI+eSsOt90UlYpE++BMZMb0DElT +dW1ZqWHQyQw8pDI9Gwox/7J1C6Pt0bG6QRzfRaVSRP6Vw+zLDEoR3PX9rpZeo4wN +aYD8HsRIH9m5o2UVqZ+ZtbaASklLWf6y8JyYTthGEqcEtRoEIUCmbxZLuT5+Jrgo +lnQ/tQtKVZ+f+FeyMXRko9Kfq7mv6191HzDcDmUP6glvjUNJw8sq3AqchCZ4lfgB +KiZWe8pNf2Ex6XmXeK9hGiaR95BaiBo7E/kbu6TsC5ccELd0A1q7AmHW6fU3bbEN +uo7C9k+OqLG5WFvRitnnxdORG8d84vZrL9WlbBAfqSJF2K/G3TLydVbvsYtPnZpe +EXF17tMDJijTfj4DqmkCRH8cROzs1kEYE8XFBYKr+A+v4EZZl41Pk17OVkSv8ZX8 +k640zuEF7jwQDRQ+fJMutLEsScIP/iCO1m8ri+NbagG6oXslfWr8WRWGyxXlAbbR +cASsMs0KWQ88NW3mUj3VFTARePWaTDnwvaOn7sI/Ejn+NrNPzvxmxVr4SwCVENwA +4VVboQMxMhIjy12accFx9bX1x/lxSNCLXJ/bP27XUga4lYJP7mMNyrMVknx9XoBV +JSENW99a1zXoyj/0ALRoS4vlX+aJ5Mvji2+DF3SiRQPyQDrknqDIJI1pKvYTb6K4 +oC9FCqhaR8LcH8rzTb8Vu11d592gcihlsSc5Mk14/AmCrSuOzO1t9K7Zy0SSYZOr +7Yz95R8W4QG8rZtoORQxbn+o0EXhM4de8wIJ1ufvO5mLKYmwnq+tmZGpOAbJTBh9 +qfHzBYaezoWl3LW+7jexodlhXUOF+TR1USWYde1Z/Om2yrBzE2aBXZjTeTcDk2FE +OeK7t+gilwTURaiuLz8TjNq3PTcKSKgVhIuxoK+UZ9InLYJaYV4gla9cJp/EG/yu +uxqquZtxZWOFH4qkb8ZaRwVAE/Mbi14/b2Q5v3xyiR0kN6gOzIPjqbh9JMUgQYh6 ++DiVIsmvRj1Z/gun5q+BHkRd5DGMUuNmjHnu5YFk4IW1V1186n2PtX6kHEU5NJ61 +2qU7AHKNhNKwDUChgU4cZLndlJN6/QG8N6Ywnj9xqAPWXSQ4PhtVIzos3BP194Yh +I9QqIpwXmQGiBEZhIPIRBACd5poK2ZJKKspZFcPzGQCswGGN8J917MOydMv1gJuk +Zc7vjpNw5/qNsmKPLpcnhzHTQeKwo2SSO52qOJlBA4RrxObdmuiQahOHvLkvIBcV +QWLAm5jCOQ3p6q+Q4tZSK2QIoKxxC/D9DazGx9gNhc80o02kv5bIR2LtNa+v7elB +PwCgtVT9WFtoeiZIr9qN26wGHqTDz6sD/jQG00A4FkQaFf1Gtcf09DgMApp9eVn6 +cIcJ78VP1BXFeAEaRzDt1dybY26tOB0vN4PRDzvG37ytuC7lsN0ugyVaCfmA29v9 +hV+dXEKwIggB17Gb+ULQmj13qoL/98wk7fMcYp1hty77s6CvLj2bQMa7Q6HWZeFS +dtdg5wH/khBTA/0drVrJwCeId2CHBOu31EZeNetkGicGTmy6Ek7XilLNzrOHHo// +XwI57sAhg48gOQpXFVgOCn2KU8IWXNdIvAYG6Tw0qfVduMHsgXQxiIs3wZoMDRGi +o0dE1j/ZjagVeu6SIEClLkKbrwleM1+yCbumQu2HJTLTzMqcFokaBR8sXYhlBCAR +AgAlBQJLvMWBHh0BUmVwbGFjZWQgd2l0aCBhIGtleSAzRDBDOTJCOQAKCRA9d3gg +rEh63AmpAJ9fzkLHcGeJ9LhWv8XOjKfCuTQf/ACgsTz//rfz0wea6V0cLOq7onWB +82a0MU93ZW4gTydNYWxsZXkgKENPREUgU0lHTklORykgPG9tYWxsZXlAYXBhY2hl +Lm9yZz6IYAQTEQIAIAUCRmEg8gIbAwYLCQgHAwIEFQIIAwQWAgMBAh4BAheAAAoJ +ED13eCCsSHrcYVUAn3Dfv0s3jRAAAAIsndtPk6S3E2vkAJkBhTCuVt44nh6UOgLb +JL/VwLnvTbkCDQRGYSD6EAgAiq9O/6M0OqVx++K9Ho5+GQnQUWNwjKCjXRYYGxBV +l/8cj/7W5PRou3nfrEepK4fKrlbMCTKG76S9emlyRSsOkcx/phZ/TT2Nu6Noi0OS +SoLFVRhmwIic0mTMcsIYLIj9qGnZlwM+vB7y6uMkyh1NUWCssQ3SbDWJWjJ4YMy2 +eKS0vL1Fd2xvZoXst187oytnHfM3hpI1oNDJiN+Ng+dioePESmOyDJdjaPADdNsA +2pNodRGJkb0Uh7FBzDx2mJRPeabCmy7602M2RB8YDtqLcYtm9/NEJSAAerS1bMEr +f2ieB5ghdQmELbd/YrDHkPtm2xI5Zh3tYeAyBp67IySqCwADBgf/VTlEVlaqPj3B +99/IsoLtWmLyZTujJ/LgcC9axK9F2EokgzhRLYBX1MvzQ2AQHc3c6PFrFjhUwHVG +DmBeWRSbuXc5L7J8gJXqSrrR5HRCgUz8PAanxqx6+95ojhsnqjWVMX9R7gGqPbUA +WmYaJL3iUwBlM6EotxdFe/tuvBbV8g7fGdvcYB4XVlHb/chVbZdf1RGCiSgj25Vb +t2r23kpj8HVvkicCSXj+VxDz+wEy1WJ3Ymv1BJeImZ3o5Ze7MXdflH3oFp87yfe8 +Io4fIxbGWlrGpwhsFMMvMR5+Coyuve5UYBK3QoG/cj/brbJtBdwxBKTpDYVJFGA+ +k1bG9q8IZ4hJBBgRAgAJBQJGYSD6AhsMAAoJED13eCCsSHrcXwcAn0AEhouj9i0J +tinP20q24JnfsIJ9AJ42LgrsIXRkHmiGfUR2hmW+GcTdSQ== +=u8dC +-----END PGP PUBLIC KEY BLOCK----- +pub 1024D/04D9B832 2009-03-27 + Key fingerprint = 616D 835B 8E58 5417 E544 9DF1 88BD 3F57 04D9 B832 +uid Alan Gates (No comment) +sub 1024g/9390F6CB 2009-03-27 + +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: GnuPG v2.0.19 (FreeBSD) + +mQGiBEnNUFYRBACdB2/nTuzObFu/B6dqTo301jF0BiD0J4Nl1qz9cP5IwrJArCzw +BQGSzN5UX0gKTpi9FWzXPWrc/On3jAk65q9FgkUTbKQqwtRK2UUjD7GpsMiryIBx +3+f1d8MEkOsFVg+bOzKqIY2VbvksM3GElCusKaWTZpgdsY27UkdHZIj/3wCg4Qq4 +ftOTc25XTEPNgAiAE8kO5qcD/27pjtQu3nzA47VdAvWGNAiNjdwsan/bWUUAvl81 +XmQ0GHlo9D0iyOd2GX9WHuguZ4/tf203f0oOHmgvYFllsF6OttBTIfd57HXyrdQd +VuI8JuKxqM0FYaQkDKNseJZH1X80d604IOWWPVcxPs0Aqdcw1F9e6e5XUPqkBXye +6IKeA/9YxJpY5QFb4EP/AyyGjIj1CsmukwBHJ+fNKribdyY5YgaX0THAjXlYLRmC +HZugmtVIF71EiDutHfq9RPiLP1O13nh3zapo9MD9CrqJqPE7SavGSQ+l1Tnedp6Y +UGWffmL7e0XBCSvB3QKf+ZxOLIK2s72Wl5Mwd6gfBEdcBxBqsLQtQWxhbiBHYXRl +cyAoTm8gY29tbWVudCkgPGdhdGVzQHlhaG9vLWluYy5jb20+iF4EExECAB4FAknN +UFYCGwMGCwkIBwMCAxUCAwMWAgECHgECF4AACgkQiL0/VwTZuDLWUACfWFyJwm6D +oAW88ITpvypdOtRakYsAoM22YGm4jla+y9lryous9eIHNu1ViQIcBBABCgAGBQJP +aMsKAAoJEBIJ5/E9DJK5hoUP/0bgURl6TEEAH3MTizCWksVPESMiXdrmiQCLFrCm +qHajMhyy35ioPvqMztH8mVaZNJrlik0mtSDiJCTx+YLSyF29k67C1+UCZsqjwcro +l9Z48wxgqVjMgfDRTZe9AMGkyvxbOEmABaX7FGJwxa7LsI6ndEKMJsX9Dfc0TEmf +vbV0iqZgfCqwaW2sZUrBdui/RSsAG7YdRu0xITx107kfy+IEZvjhTXhLqunwZ4Dp +RiOAvqwF2MXD/yU5ZYA8GVbdyLQtgRVNvvXTmeiJgn5QthQLEZ6YVJ9T1sqgi52c +x7Ru6rhb9QXKlrL2ijgXHM25WDTMPEKadoY5AUlMr3r0qgL6vTfRLm1e3l/p1ZOR +2LzOmi/JINKTmudn0Sn/loNoGbzqvt61gC569TxBbDo6urzdY7o2NOk0TpQqbeMH +fsEx2MBKE0EpZyvtHbuYyNi62lWqZzf0D3X9PXuXQlPXacKqPlHfzT00mfkFXj6B +c/c+uvudJtWNo31ksnC9/lxCKFsnx0+9plYkev4cNk7bH//epbBoY7m3VmtWLSja +kqsQNP+45QESD3YmRgI120zOvzTJiBmjv1KT3CeVoFPSkevI5zHyTA2p9pz0vgL6 +EGEL0pCMWZmepX9PZYJtyXunCCIf5yoUwxxyreOPoobMtyaAsrjP8EVbuzIk5vzL +G+x2uQENBEnNUFgQBADK2OL+zY/4V80Bans/v0sRf8cUzB82eW84vMgxRmMS+Kwt +y8CBwEV4sgWbv0vJwifo9ZhlMLjqmBwGTR3wIXqtRQAyk8rLYod31KWFyt64vZau +bbxZNDxiM5CMFO+q3xjLhbsMnIC/QliKT2d0K2radTp+jNz7lOkmSvZ9iQ7/0wAD +BgP/TWsRYmViLcUcOa1N4Cij8Y3c1tD2qYI5b9eDY5GiOeECss0CudJN/cIvDNst +LtLa4JbX5INRpskVTVsxDuermrsj5/tONUb9GwBnhUuzA0GW1WCkpZXJG2Z2iwKc +J8wQ5KaPj9TNdahF5h7qoutJyNeVe9TC2PytS0tfCzd2lnOISQQYEQIACQUCSc1Q +WAIbDAAKCRCIvT9XBNm4MrvDAJ4ySDj+5CSCB+DQ8PotTK5oX7fDcQCfc0d5dQrq +c2ul8/4WDB/LmNcXuhI= +=eEDK +-----END PGP PUBLIC KEY BLOCK----- +pub 4096R/23724330 2014-11-08 + Key fingerprint = C643 7A2A D53B 3E5E 5876 C91D A645 F248 2372 4330 +uid Gunther Hagleitner (CODE SIGNING KEY) +sub 4096R/0D0A9762 2014-11-08 + +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: GnuPG v2.0.19 (FreeBSD) + +mQINBFReg2cBEADMnO738LiBL/pXG3koCy+aM9tG3ibfLGhOZtwHYm92HN6ANyQv +fThU0qNJxHTctlo1/ZeVY7nminih8wswbLS42V4vRalg7EM1xjygm0qiMIDc/G8g +hxc10SS/VV/u0ZqqBGpBm7ifFBWyn54Rvq59TE9gKXFx+EgFKve/n1peZZcfHkR4 +l3gbTi0uYGjVMe+hMjmhM/6Scenio3paUnpB7kac98fjALWRaTrs9S25/OxIK01g +t5oglZXbwpJsx0J5rcHY0useITPiIAsF++ZkCpWLb3Q4lMWPZnZ7496P8+qgSubU +/OI16+gXxvfSo8ZKb7SrpPHIhOBpVXGk8fiMD6lXOF6ETXPl8XnQ9B2rTWEFzdnr +jXx4tNnxL8KXd4O3dNPoZHUAD5xNtPAuyxvgC95b60tBreHdOhPxGB3wR9ybsNP4 +dpnewNQ93FO5z6yTvWTmHML3UG5cHN5bVv3h0E9cEk5+7cGteaOH6cX/DsUFbBta +hKVGCAOypXxy3aNc9Z6DQZB8FW2bgLdoBkjaKevAl5KKPD5iKLzU7tQ6x0KLAUIb +ZOuBiihrnOfU2TXeYjBFUPSQOadeYEzv0hwO5GeWBNPuMO2szKRuc6AxhhGa+0KZ +roeNQIsjDWtP193VMVfp3Mz++9yavrrDpFyyeUwYcQ85byQvE2DbZGY/RQARAQAB +tDpHdW50aGVyIEhhZ2xlaXRuZXIgKENPREUgU0lHTklORyBLRVkpIDxndW50aGVy +QGFwYWNoZS5vcmc+iQI3BBMBAgAhAhsDAh4BAheABQJUXoS6BQsJCAcDBRUKCQgL +BRYCAwEAAAoJEKZF8kgjckMwpMAP/joVpzJOphuB3KDMDluxbWGIz7vfCDGt+xaS +LBGTVLbq/iix1Qfc4cxhAcupksvUlTwD/OaW0X842wz5u3/BZzE2uBZ0zS81ZG6p +iPL8/SzrvDIFbVxD1/R9A5lfYAEz/EYOTrivplIqeTJAucGqPo8tt49/XKTha2w6 +MyCzNtjtMA4OjZie0NBwZ6wnfUavtgTu3ySkQL+1tNGu/2ViCjDWdKudHnErf7cE +iYnNNt9kXkROc10EWw+4MgsedRAj7Ker9aK5TihzFzO3DWrcqebGM0yG+7mSMXxO +QBlNgHrqEnBxWZoUqkSCazY1aQXt2iyzlt7XRKYznzsGyO0a0C8nHVS6dLGY8e5B +A/2t3+2DD8r0QP8h2ntWhxmN7ZKsCS0IgoZyEby66kQUbuQPnzDc9xfJzhh2TzTk +K5vKGO3jjVq9Til9h+LK4TB4op1YPR3STUaLSOPuPZE5Up8EWwc/AX/7uIk7Jk5G +eiOTCxMaRIj9dPjwI2CBiJQMIITJtvvf5NMy1vkRBBxT2aeecw6KH4xYUMaVIg+e +0K6XwMVUXkyvXwVAan5RTuvVoGUp6ANW9zVF2lfnTk/5IIjsqIqZwJ0hGKHlGUwN +328YVrtKifNHGdub4qef8WcR5lRh2KEHxKNMkID9W8QsOXQWSR0vWJsJN+26/dvr +WjxhLv9muQINBFReg2cBEADNq2T41Ku5FRkMEWRZ/ZNO4TktXbOohGIRUk6VkMzh +78/ebUggBEhup3N9o0/vfHydTAwmE26pcbZvnc/aN/wLpIdDeTXgazvuPKo/8xYr +fJrAb7ii96DSv9rosIl8Y/oBO1CsHzPDyryGebm32/PdilC+417x7WF8KkRWBan2 +PmXIQhAIPaCRj93GznziINJbEoiEznDxzDP12hwhy1GviRn0rrCakc4WQx9ILUFS +weZD+1V5llKRD+Q6F2FC+XKpoBlczUHRF2K/3Pyp2iy3+tgwwIWngyRuzA/DpCZN +8b1GKY9MdD9lrNKQPvX6nR9tkAJE21m7MYsw5SV87uceUAGz4hm/BkqN1/Znojgc ++SFIdhT6lgFKqcft6VO4JFKashEGUreMottDhsEHINMvGnOzgddFS09ZYllzgKR1 +/gmeSJqWwcXqCfkaTyoVGHgLWodWc/v+87Rw5LF4oeOeUKpj5u8Dz4iwvi9HZ/yp +qWVEq49oxph4/guK+h2HlU6tiiRyFEyc0SgdAstEWqiwZyFFwDFPvQT4V+LZMheF +7MC5ERS3QyeIhUsGS/LHbM4OYGMGUN2zrY5vtLVUC8exfUc7/iTRG6uLnCLG4Iy2 +WtwWjEGC99YGJjYGA7wU05mdZ78o/DWFsVKyNcVhFUtyWrG21iNGTBib3p/fKzn0 +0QARAQABiQIfBBgBAgAJBQJUXoNnAhsMAAoJEKZF8kgjckMwBxUP/1y+Zqs8PNv9 +nD3Q5uuEbUNUTLrLX9hvddONLIlM5t0MyirlVkrS/kQk5KJ7EL6MTSfYKsRgUqoT +zBS4SAMpPLdv0KRl7U4A/qNmyL4N9FNeECmKSYPGVPAq7y5HGnxYA88qz9RQKpFX +hk7bQtymWZo2VKzHq30LKRmjUmYSDndAXGm/6Oxy95zibgjBrDpz6AUywP2h8BNQ +DPl51MRgLZHBVCJS0o0GaZcPOMuv4tys36rxqLrbuQ3E6/uRbFEBypvK7N9a8ayb +6d1LG8LzEYDWnjJPMY59+JnbmZS0coIf6B7bwlFYGHlX5IUHLc1Ep+6i3QHtbDAq +xX7Iaxp/iWErZiianLpLH7SR8ybDHoNDA1uMFqXJTxyd588Tqv7sSYv22l8mhfIj +6M2WtuUnD7NtKHwiQugPCUICI2pyQK46HHTR117hkRcNMRI4s+5hRSSC7+xrNm2E +4DZzX36EIJpTZ7Ihk5221wiiLmAbK174L5FX/RIyi3kApxxZhEtmPhHNHI1d8UXd +gCDA66oYKDh+ttMTldCE1RoX6BnTMh2/zD0Mi4QuuKcH0IHd5KEgZX04HIzsX1xk +HKT/L+vGBBAgsxp0h5KbtvuiI3iO15WHk7VBG5Vz54eyEhziFNvU2Lee8TbXL38i +P3MHVkGLSfQikD1PQnlUWb/9Jd03BMLY +=L9YE +-----END PGP PUBLIC KEY BLOCK----- +pub 2048R/10C7DD20 2015-05-12 + Key fingerprint = 1D86 035B AD3D 9FC8 A751 345D 2470 3C6D 10C7 DD20 +uid Sergey Shelukhin +sub 2048R/C6E7C341 2015-05-12 + +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: GnuPG v2.0.19 (FreeBSD) + +mQENBFVRbw8BCADJyMGPVuErct2Rhy8w3s+fQyHbQ8eTcB755JH5oEtjBfrcZ4DQ +Z7pvtcbqPSQHLVoOdrT/EvNVEbs9Qrc5w4Np+4L6AfffuyCNoPG0Fz7cfnoFVrAH +ppmZruLWrQ5QN13Gojum6C46ktroqMtbS/wNxX2SUANCismhVZ+D87zApYTs6kG0 +/0Vq5umZ4KI49NQibdq/5bndO/YGMONvEG44RpkS7rh9YoFG+ZcHxzjw0KeuyHbB +3LSMElnv7z8GDC28E+z4gbNfkm95RgtmukIgLuA6mievGe0V+tbjdeLa9y/w5AlO +cnsDJROK7+7Kuonj9LnPa0OrR8Dv/4WW1A4DABEBAAG0JFNlcmdleSBTaGVsdWto +aW4gPHNlcnNoZUBhcGFjaGUub3JnPokBOQQTAQgAIwUCVVFvDwIbAwcLCQgHAwIB +BhUIAgkKCwQWAgMBAh4BAheAAAoJECRwPG0Qx90gApoH/ilohrR+Kvzw7f0xnUEy +MAIxo4WIiYyZO/7gz5ZB8lW86PF4VBQGvN+w18PUwzCwyf8cCASyj1C/YNrS0zWc +YVbpJ3KG5x8SOCliOegCiq4TCGDF0EBwXbXvH+Kq+3qmSCDqKJfck51jy1xf7rye +PtDRGM9RLJq5/GOZ5aAjgs/w/ar4vDzOOA7VaTFMBWVTgOFf98Ic5eVUv28jAE7M +GjEBn7Ic6fpPLo1lKsTEKfCjTe6AD7+3dSuXjD8b+izyDTQy1gAASVcEcGxkHXfQ +YkuM7cg/KJ5+osSYpj16eiXG6uBUlpdCEd/mTUtOdfX/CNxJBJnaVFOY3fIBHKwe +ZQ25AQ0EVVFvDwEIAKvKUz2xsXXTc5nkZs8lMDDeGmIwpWqwBzlA5nXOvUwHfGrC +91j/A2khIjUeZ9vRXNX4QmmbmEElTgsUmhVGvauvSzLTGWfHO/KaLqyVJqhSw4gS +uVxi1RlKOetEE3bC3MoLTdsc46Wjp05GMdPTEGAMfPQR6IlTwjvEE5nuFICJNQmp +x6eJKfsPQxsAPrZ8w6mneFpgoJcW5avGm4AMjeBdIsCyUI16BMvlzyb2T7XvWjvi +7s0LFfJxq9v4AH8c0DcoyfeFAxFyPEs2LKV4Ac/ArGIv+38twP9JXou1hps8iaaB +60zy+YJvEtqLhvHtNSjf9zSs8vjvyqB6KJIhwLcAEQEAAYkBHwQYAQgACQUCVVFv +DwIbDAAKCRAkcDxtEMfdIPRWB/9cMsKWZ+OUXeOkBTXIR3qyzE36vwZE9q0S/xlZ +Ir2fDW0O7mwZJ50FaOwSyo+KXleCgtN7BxvyQ23hF/R6zGag0eM1Wzg4pfAFxhpu +o8Z5rLn1Q1/6qZvlFXJfmhZKWoU4tG31WMMkJPD7V0mXO2ziUe3yj0791Wjkk6dX +WIxmOtw3eFRbFWyebC0GYIHXvcDmYON2rzrkHN6S04B3Nqvi6vQQVzqeMBOAbWEL +xHC4t4b3UkU659QK/jwhP9VPy42TybLJLrbM8JcxrbQKQ+gE82pffFTUM55Po5I2 +A2hxt8qWjMTMGPeAjjAaD0i0eMBZDaftl/plM2AOFtqlUCg5 +=d9lk +-----END PGP PUBLIC KEY BLOCK----- +pub rsa4096/B5BB95AC65C468A3 2016-08-25 [SC] + 2A4B755C5EB54F0B242FB7C7B5BB95AC65C468A3 +uid [ unknown] Prasanth Jayachandran (GPG key for signing releases and commits) +sig 3 B5BB95AC65C468A3 2016-08-25 Prasanth Jayachandran (GPG key for signing releases and commits) +sub rsa4096/CC4B41AC10F9BDC8 2016-08-25 [E] +sig B5BB95AC65C468A3 2016-08-25 Prasanth Jayachandran (GPG key for signing releases and commits) + +-----BEGIN PGP PUBLIC KEY BLOCK----- + +mQINBFe/ZeMBEADFbg9eRnVhBtwrq0t1DkNx8Yn3Yy191eC+UYFYr3xE3GlJTpe7 +7QTII9hJ/vvkCLwOtxhvUULBWn/CuSuCjASDhv90lCTEd/Zs8NwLvwJVgUmHpbQv +Rdv04DjH8wCpvndR7ZzPSrONqJC1RkPwsRf8ewRhQUZy7F0G0sW9EnYAd3woJyOs +23/KmE/tgdHrClUgFDSKERw8CQwU7pF8Pra+q2Yj2gH4CjwGuChd16hE1KRZoB9e +p7/uCK9mLsvpwCVhvgTRlAB23d+1w6cvAMk+052eIHBHvYyJgzxuN+CnFuFoyIyb +CHyjh0reQjFZTJTHJOXtUVnjqUCtVo/aFCmJ71sWVw5xURnsyfSPzrvvcsrhOa9/ +4dibfx6SkgKaUzXqFdiYfZv7lhfaxzIhLNVq/guNS36ti3bwqAFHxgRNHpRdE+HE +Z8DA7L7qfVn8jw1batPYoAPpoQcGBuP7/ez8EFlwoeV7AbGdEP2oT1WVPS2HQ0e6 +cfPgq5LFQU5ARPAhtEeNC3TOJBXaCuMQn3sdzPrhablK8z/klLIsR0V34H/GqESK +Pc2ZKhwZvjvNjsGvg60nL/TSgPRvdhMbawlAotAKUsNlD27QB3JJ5v89vWfWWNYj +C3LiMLyU8YuiD+COWXrQfJW0uXdIe69fpxPXVGUctIdhRXliXLxvis1fiQARAQAB +tFdQcmFzYW50aCBKYXlhY2hhbmRyYW4gKEdQRyBrZXkgZm9yIHNpZ25pbmcgcmVs +ZWFzZXMgYW5kIGNvbW1pdHMpIDxwcmFzYW50aGpAYXBhY2hlLm9yZz6JAjgEEwEC +ACIFAle/ZeMCGwMGCwkIBwMCBhUIAgkKCwQWAgMBAh4BAheAAAoJELW7laxlxGij +ncMP/1S5NsslEeUOVMUxLG5lIbu6+CbdRyUpRjsxfcuMxbrX+DO5oSyVREGuG7t5 +hiZWixQhFM68mkQx8fF6ZpxBEIEsXcJtM9Z1wEfLFDybf/MLTxF69c5QW+ghrTS7 +EWbxJ2bEIlhEwDSETYQ843zAQHWplxtEcfr5PJDec3z9n9rknfQU9K29Rx6g+93Q +2M2/z1CWC1LthPNoosqlNIztHl/L0eJn5mAqy1tG8es9Q+VZAeuSGOrz2sXhNsOk +JOYks/FDXvj60Vgng5jXdA0m02+OimrG1KqnvxZo95qbWQAqR/8uuX43AIZAGAGu +G1cqaTnPjz+kJVgyEGMsPw/8L7ojwW7yFzlQzajlCYs6FbnnhBU3FwZPY5Ffk/QC +P3VusynEW7Gffg8Ko4PslAh9eOZOcgfksGYdolhfYyZHGfHXsbXRuh1cvfnZPaa3 +ld9586SZV8CyOydkwofN1wY90RdB/87GHzHK0zEiw3ZQicWEFrtjVlozNCb5eO1I +i+Sk0efz8Z512RCzyX9bvqdqJixWrwNXW/AqnLlby4g7Rw6Qe/kmlFwqfVSBtPWr ++2RcJW/PzMH1BicgpQrtmgapQTtPlinF5fQfWBTZYrZ3RXAItXh8DHc0WdI507CP +h9ksmfGnQAipBcU9x22XO8i2X+pWnefr6XPL2RIBHFNMRoBXuQINBFe/ZeMBEADV +Mw6wWvMSZ/zmyR8MBhM/Vav1/dfHsF4i5qf75OpRm0FI6EXp8D9P+3FZie1pvovf +j/5ZmTwa0+zCHGu13QRqfSxYpJPEbCLREvHATo2+avcrWm4aurvKWhCbg8MzIwWr +31M8/pIqwYdmJmnTotDFZZBDYaKFzEUGGAkEIhmUqHz4evluE6B9t8FZH0bW/PWT +7//cxgiqjdJ247gxCsityV0k8BNFmQxE80LdxXOEYEKEa/UtpVFzd/IKCtKdjqDs +JgAgj7IN5mzm1S6XuzR7YLr31pJ7/a7+aMggdsFPXFMIUqlxmfAkVer1DCiS+R/m +4rYHOsCDptnjgnYED0PA3D+xB4vyqkziQLHN84DOBx3czwLlvziDacEXmTbUJktc +QSCmASYMpA80Hl4yViE/RWS65D/Weur4XqdlYRfyicUOlzKu7i0Uqxus03L+H5JL +FJ9ZVsiu2ipIicK252TZdG3CoPS0g38VdYHt4adC2EgWvTKOgultlSShS0cpz+lL +iPTUa6rSSXqHIM5oMh+qhehamYtwtjD9CTLnUAE0r1zZaSzm2wk2FDNZatXaKB8K +uEOwa3EUWfj5kHh2dqX0TzkWGYKuePD4b1Y8Sds57YIuWZTiir4uH15pn+bwkxS1 +eUNObWGUoi08YqCDCNltUGZucnyMPpE/79Z2ptJWcwARAQABiQIfBBgBAgAJBQJX +v2XjAhsMAAoJELW7laxlxGij7IUP/0Fmxp7qwIFdEC58mYssCxelFjCHiHRxJ1Ju +/GDLtiIkuNQt0QjjX8hIj3Xkp8C6Ct57VoUoA+1NIII6DvzYXOTMjaNCNPoBaPoV +d1SrjKes3IId5vTlNnmqIqovYZvr7AmUGJM1ZIl97b9qX9rP+RfyXZdqqR1EA0Lq +mtX0xUIpbhthRmpgCtPV+qI9Hm70I6wUdCHMNB45KYVQwHD1aAH0ZS+kLMbmCASs +OkCP90r27CzP6xsiDsxQWcGDdwtgVVz0ih64KOzvAQjLoxpgKhQxMKBgW1OMC5lU +5G8k6HRZ+hdM2pKrTazcH6HV/0z9yHmfgH4eOpEFuu7Q2vXmwipm/qR/+8wkHBmS +UblimjcR3es1+phxAKNfjCXEE1n9pkUa63RJRr30IgfBDI2QKd7eLgYsVP3ghQE5 +7kiLnbIzUV2atvdHWnlgDdlBo5IRUFNh094HqSkzPe0aiRCQTPFP2qShvPyCf9jE +wfWzfNXuvOsNfhP6EXPkmeSWRRKhF4Op1raC1UYjE72dRpjDoEvShGsPkRZM5f9C +gYDp7i1FrE1ikFhHiyabKUcCfsbNHJN3AQEX0EJwpvOb+jzQsdkOb8qy10nBW8Rk +mOba1VsdIFZxy2kQEnsv4HENQHF7q7EhHo9nFsCGHtvLlCTV+6IvwUb+s44nnqHS +R/khDam6 +=/Wxq +-----END PGP PUBLIC KEY BLOCK----- +pub rsa4096 2018-12-17 [SC] [expires: 2020-12-16] + C277339C899E89E80F9C38972CD997BAF60037FB +uid [ full ] Vaibhav Gumashta +sig 3 2CD997BAF60037FB 2018-12-17 Vaibhav Gumashta +sig 1209E7F13D0C92B9 2018-12-18 Owen O'Malley + +-----BEGIN PGP PUBLIC KEY BLOCK----- + +mQINBFwXntcBEADGqazXURi99+VRKEescsv93fvfRw1ZbuWciov6tumeEPQeAYO/ +92zaEJobECy/57LUlBp4xM9+hWeItxv57/Y3oRyE8TCYq6vZnfNZe8Mq0i6gO289 +ND0C7jUi0k2X79DCjv2FFHArgmD6RGE3YOKnjTKlX0HC2MZ4lGsKZf+4rYFdCRJ2 +kDPcwONRCezwSu6oZ0beKW/cjm/t4JVjNYt9nQtIH/3np9/z+VveiZPRA2CK6/fC +sk4oaFEYUS3u8q5zYQ3yjCtx1fZb9+/hIGyPonTKmysictQqNt38P8srdqRE6f6/ +jJ/aB9RmvS3sb0VErUXtH08Z7MDUPzPD8VFoSLrYSuEMvYkPtRMBl9kk3UwjuQSb ++tGU0IdkmIVOMBoB9Ek8maMWIx0mQH4Xd2a3rCZsBRIkuCh/PW1n7GUU12C+K7cL +bwJJdN8AJT/aFtFRyBUw3uTseGCQTCkzgIeSTxvTN6kVe27MNf57vC5zwNUxSh31 +6zs+JKhtM6WSoZGiPeu7YXyCBKgA+5ZCrLAfZ2GEMw886asDc4BGOO7xwTIfD4+h +iuddbTMX1zeqosQfc1m8rkHwtj2mDdg2JFwLjDEuAi9a572za5fO1wHyAQOUdrnj +1jiZc6zF6sUSlbpv+G/f5TZvcPR4yr1kQe0O2aItL+QD2rfu9C8RXkPc2QARAQAB +tCdWYWliaGF2IEd1bWFzaHRhIDx2Z3VtYXNodGFAYXBhY2hlLm9yZz6JAlQEEwEI +AD4WIQTCdzOciZ6J6A+cOJcs2Ze69gA3+wUCXBee1wIbAwUJA8JnAAULCQgHAgYV +CgkICwIEFgIDAQIeAQIXgAAKCRAs2Ze69gA3+2kkD/4mO1O2RC/366K4z9pUTfvE +4+TkPSs4LC7nlkvnJU1dhfW0rH4hyV2p4GC/wtdsNXMp5xSLtpUL+nzqZRkGZMjZ +ZZux4+oRlDrbToy6WNtJUO07NR/JZxX85B9vF3XeEwLtPjG4FqpM/mLK7dur9iya +n7ogtkFUL2il83ctHgf3eIv0CAGHnEzH8zMCKEypChVT5CkugbP7dgLCzqngFPFh +1/Y8pMyT+C6UPOSaA3cWmrLml+iNvxpzt8h/U4vnb1JsSdQwwb9M6ZiMc2kN/SJB +5CFDISg0RBFj1hXaryKWtGVrfB/n52lCncFR4M8lGbsuz7nm8/59LdzQd32GSjKc +nn+FftiznK/JagnqIuWU894Q35yq1oarpecgJf7W0w8P+PQfODogYtlerfMKrHOb +oK42IVg0g+CzqpZ7BKnIlyhay1evqLvdJha1lEouGN19puNDNF3CA8KXMqQB9zBp +nujCvrBClpKhEJABHiIbtWNGRnsq3vZ53lz9v1n3BfeZi20KcMjPcQQPgqB3lGVv +ZSB+WODICj6hiTYbLqCTNPrIVJgRuJRUY9ekbGMILnF65mXATHufje7h/DmYBRVQ +48ManBT054/+FN+mt3hI0sT1Spfcl8bC7KQrlfV5Y59gUBGmog3UjwrNKi3BVtNz +pn8f2U3UNhoewCUYQ927kokCMwQQAQoAHRYhBEdmC8mLxDPwHlyQWBIJ5/E9DJK5 +BQJcGWpbAAoJEBIJ5/E9DJK5Ld0P/2kFJeuT5IToSlyie5Nc56TT29jI4JszbNBM +nGJd1dpdJKHjAqfVVuO+ctFbkpcB0gyt1MpZvpv/9YWL5aA29g01gwoxW9IDZgMo +9/F/BghuwdtmmFJB9ykEE/rEKEaK946R3777QFKBQRIx6ESc0eThJun6dEjkTzvA +qaaDJc5M3xD+hNZWDfKlLBUoXsnToQsEwXjo+sZxBOM7YGeIKcxds1KRMertOE2I +1pNTa5McDv/S3YDJFvn44vAct5PyDHCxVTAObVfrzTI1kNsH6fI2QIQKZkDXqipD +FuXsnjz/bE9+IPWNJkBcol4LI/xFdnJVNGM/fc9eVjOr1lFNrYhYFB2tNf35J4PI +FWDfcfeKOLBgTLi2FkfyxnFVf0ll7p7/wPbB1Mi6Y+4BRAb9oH5qcwE+1ZGJVQZF +c9f71q7+I/P7V03o5HaUON0GvSDvrr3VVtmxGFaTCMx0i6/X3IyNHigLc+VEJgoH +DQUWNkufkCLEhLBqjRlOy+LrsOBJut7wBvsI+TFzbmEQlxOUNHj0M3JqEU1ReYWv +lFGxoDV1kwyjGmJHi2XA5dL445tTKTnWnagGTqyeZ1sL0xPAyWsu+PdgbwhiDeCY +1UtCIcCzJz8xjjkqrNYpJ3EDckIG0lplVUutcU1uksMdCrL8wLyl2Je+2ZlcKtv2 +mEeI/7OR +=v+DS +-----END PGP PUBLIC KEY BLOCK----- +pub rsa4096 2015-05-05 [SC] + F28C9C925C188C35E345614DEDA00CE834F0FC5C +uid [ultimate] Dongjoon Hyun (CODE SIGNING KEY) +sig 3 EDA00CE834F0FC5C 2015-05-05 Dongjoon Hyun (CODE SIGNING KEY) +sig 3 EDA00CE834F0FC5C 2015-05-11 Dongjoon Hyun (CODE SIGNING KEY) +sig 3 D22CF846DBB162A0 2018-09-05 [User ID not found] +sub rsa4096 2015-05-05 [E] +sig EDA00CE834F0FC5C 2015-05-05 Dongjoon Hyun (CODE SIGNING KEY) + +-----BEGIN PGP PUBLIC KEY BLOCK----- + +mQINBFVIx4YBEADCRN5gDmObS8L3e2YNFNlCrXxSVcUgJ6UOYt12wi337dEudEqk +s+0jZ6p9k3mz1hD3uTim+lT/O2ODRDNWYBfT2cF6E26QGieXrKTxeApwFrXyWuSm +49rlhgxi/ECGA59ovPMQvxrN1b8IFChWfXR9lmIllUKJ02zNnpossEPdHs6k2Efu +dgMlxhm0qFn5JULDfr/+ump9n9IeiojpQ+bsD/iZ/7DneK2BqtHA7NGOKCMjRzhe +OzG2lxwyLxB4zR3d2AUMlLDJUMAjR7MOEs7B/d9ES+ka2HI/CNc19F5cD5soT3EE +D7B6HwCRNPSyeytwYCafLCaxveKpDWfehUDNFrSqBaxyDh0/i8x50GrR++AsItZU +gh/qcYF2ju0uKZ4t5UVvoOOCBc11njzdk6VeE6VTDoRFXZ6QUP8HWR+F0PdLZKWf +e12Pp0dMwDcWppJRC6zzbfGizz/209VSkF4atIU9rJmB9T+rm2RxL4+l5QjADWRP +1U4NMC6Fh3aTR75KOtL50NMjk1H4o33KX33Ec2k6eJ+9kDcqhRb1+lA4I1JZB2pX ++crvehzPDUh9i+nVXPyxUhgC1SY3+I5IIdGGgz69KPU8da7l+MRLxL1YIZOnqQnt +3KdBRwpFzDXGK6bAhrboj4Hab+GIHBRpJ89pJz8uG5CaMFfWvapGbC85DQARAQAB +tDZEb25nam9vbiBIeXVuIChDT0RFIFNJR05JTkcgS0VZKSA8ZG9uZ2pvb25AYXBh +Y2hlLm9yZz6JAjgEEwECACIFAlVIx4YCGwMGCwkIBwMCBhUIAgkKCwQWAgMBAh4B +AheAAAoJEO2gDOg08Pxc4OMP/jTvfPE9Z+n/Veddf/i8Gdxurf2LiYgzHFu84CfK +E8vLxo13PP8DN4ZNBIRx2+a3OQ3/PLTpDn/D3Pf9uFriKXHNGksu153TAqMO5x81 +Hc2vaRbPStUZrWLcIsBmGlZVR4rzuSF1ypFJ80m7bGyVYQFL4rq9sd2E9aPwy9zW +GBjqZAQuIfldLnOfkpnDS+X5J9/12kB8By7nvDydQIgTCJGxiLGh71cfmZDtTJuH +Ldfmxw+oiqfXEthy6UqDayLJRGqeMJDCXZGj0HPQZHZZTDtF8czH0w0ezj6WePD0 +dnpm5w/Yg3dwQ2jWfkRAe04Q3um/bTzcADWASQtoAOPCCSe0/JT5fXo86uwdYUBD +ivx9OABzbgQZlq1Xj4YbRNF5QUvAq/k76yVhftNGaUBT7ubWyxBWBeh43W5g/r5g +gvO9XfQjr+Ox6efblvvJLMnYZe8Gmd2lbuFWfUpShYXqf33rfsKHcUkQuTEKFTVO +tUsgDMngFg/K3R/Kg9pCX1BHRha1o89mBcwaTW0KaZ9sTZ6pjo58f7f7oWEKBfpG +VWRFlQcqiHTzCJVVWnk4u1AMk7+M5xqSHspX0YOHKFl4EXRs9bOtX+NUu2+7vbY2 +B3D1fzTYIqEGdZ3SGh6yMyJgzi7/k+jMmx1O/rq9WNspO630JOBDH89PcxibDaVw +5pPQiQI3BBMBCgAhAhsDAh4BAheABQJVUCtkBQsJCAcDBRUKCQgLBRYCAwEAAAoJ +EO2gDOg08PxcUhgP/3gM8nw6fEQg+SKT491Hi7OCd8w7FTAo+SEDStLLb14zMu0g +QuI4c/B3a4mEAvKko/325zH2bqra9l1dpQvErQ1xXvPxviUBXdufgW630fnzb/e2 +nUd5afexsXoV0SxeAMPgJthLGyNHo/mYVvx+l0uo40mv8sbC1LRCBgweJN8J5WdI +Kh+PZ68h4rVwu3AqV4e6mNSuTm145IZ7HbCIio1X7EATeDM3ZJxrhIU3zAHs+DpG +jX/U+27ZhSOeoo0z+gpTOxWiG6Hywia/BFaI0fR6BK4HQjvW8g+EiHq3O64bgMos +lRaHTLKnP47zb7/FLLtYBYnz92L7sS/E0ay9OKyYTsoPKGFOIBk54qc4ogB3Arwz +9M0sJoZS9sIbfGhMXN6K/Eb0Jboex0qhow6vnVCiHasrCKMXr+5DjOBrN8AZbcsl +eD8Gt5M59w9iY05uRNKxRJj//92ufJm0C+c0V8YPYl/ZRkN+exi0Y8+7HngLk6Vv +s/WYJjoU0XRX9YK1Y4jpjgljD+/jKpKvUd/8L6pJNY40SXkqcJkfGbUz+iKnbmIR +OtPXrBV+uUnk07W6qUCGeSfNMAcmyGE/1z2FrhWXZ/6YFqSlSVrPrhGIzFO6TjbO +mrzSoLrvdhy26RwnJUEuTYHIxm+z77jSJCW/MkIsXlaA2UF8/wemDeYlkri7iQI5 +BBMBCgAjFiEEOCN+5CUFAoUHfbV60iz4RtuxYqAFAluP75EFgweGH4AACgkQ0iz4 +RtuxYqDGQBAAl96xMMnzuxM8cUSdtQSHk8n3UmrvUn35c3B6NGTLN69vAbG4jAlT +1BC+d+Qm7HfFcmXtyXGMNvjw7zc5iIcgtMcJZcoPHXpTGG0vs9Ic8SAXZ+Rtnw6p +Kr7fz1bOYmw0e+Je19jYN07Vyf/mOtaLYbBjIVRbafiF70kdLMMMOIGcL0u+ZAco +6OXU5YvQDhKx8krFLMJaGsQIQA75ixUpQGdgTtA8EOpKoBaWbttVPZzTh0wLQJjk +CU89QImEQz9BK3gJN3hXtjtR+RDQP1FsF7s7UPixZe8y+HjZy2Da2p/DyjKuYgIK +gBB0kIpuCpucPNHBkbd7G9sWZG7ZnY80NcvgC5cOZki25pgGV6Goui1xvgrdizHY +HE1e1+0GHxqYR982YdbhcNA8vnrF8RwOmkVVwraqrw/ao2fgDgO9F/r5T6ZiJS13 +zOStloTymffS6YQcLHHMzsft4WOodm4FdrWRWOxL6aR6z4bMcT7MgEg6of2BF1XK +LfafchaAhr3DhTkHXnXOyKhGZYSsnEmWeUg1cwZwABesiZuWaXDRzhGtxMBlUgeN +GU1sSddyg+x/YnQLW3EsPLPH2QFKOuqceZl6qfDE+FIb1LiTleO8EnqEwL7teXZS +/pePO4OZ1xFGOieIEH29II8gzkehnOQhzemP7ZFkZvfLix/XQSGQwyq5Ag0EVUjH +hgEQAMpFoiU6n2qViEgPyft6wzLvld86WIo8DGT3J65lZD4Fq3ZnOd89WYuSqdjj +FJOpVW8WImoqZoWdVr3dhPln0ygiR3nPQDmCxK6Q6Jh7jznoWuW4bM2wwn7SLmtJ +CVYLVijM5AIFYqB8hblKdqbqtSu8hWdUShlpMxLRCohid0a7DQaRoIufThXJy7Zb +3D/UyPnKlh0cxkRGohoKO7vQ8NhLX4xUYpy/TwPyME7Ljlk0qEgefLY3o1B/z5aY +Gob6FOXtq8T4TeZHHZbL9cXqwdLqOyrCBIcETzT9srUfZQxc072odIUPGxltxZio +LbMUXLSszmmgaVOT70boPDSJRjWgonmHFOSAg3XIvP2pqHyXmq4yAApxz63kfz3G +grWCdv0Jkms1UPnamEpnANTfSCH8JqxHFU1Jaai3C4lHDH5p0GGSVyUCaO1AYlCi +aWYErovNBxuX3zsHBYtAl8/H4IlEfhWphqiM/ra8pC21C0Ib8/8hCO7Hn0jlHCSJ +JghGCLv9G9d8IQM9lET4Y/1vvtNjtGPs1bjei4alPA/qLvwItVD9eEksDrfqjV7T +E18B20tPWlluycJPSyngGi8F96JkYd2jLSiIBUfvxtkfVbT2gorcdeew1rnzdUPq +H7ovg0lLhzFqCXdNgjn9gydf8BVDG9ldbja0AVMOaqqZ/aKhABEBAAGJAh8EGAEC +AAkFAlVIx4YCGwwACgkQ7aAM6DTw/Fwqxg//Z618jq1Q5UrQ9YSyevCs8B8LiE5s ++9AGNLVxxsw7XZ+C1pCVmR5SAF+QoSGKZ5ZbazdrZWfAI3cEKpNbZ0To+KLzgWsv +0jlVDXWVYEwblurf40RkrPORNRQKDduW9JF4NJSjBPHBPMgXb+ilPYgNF0H9zjRY +5v/ubCAZvTPHGbjJ7hf5Dd3y7EWEpAZSqyxjPfsODw+c1+oePI5ZZU89fM8e4rBp +mUTv7onN3uZO4KCFWLCWJVPzx7SgIzzm3oObS70+A+BCdtPNLgZ/dn2Jl5l5xNzh +WhcEWkXGvnaW5cma/L9veVdOAHAXRKxN8eDtVjgrcMa1yKOD99JUPiMId6P+Mhxs +WAUPkxHHC8Zs4b9zkX8oqpJbT/0T1yvyklclf6bmWUJTgL5qDgJTjVIWHE4bxD2/ +rRl19eVSpUmntfF72Vd5Epk8cKMs16lksNzgfBG3JdxZWt6rbDdT+Y3cuqGhBdPN +1QI76HBsxULzsLgB/OS3gs8R40B2bB3TSFvl5269rUEJQyj3Nex9g+ZR3XBlDC5X +N0UCJceY9kghvW7wwk+bzCuo+pmYJrAtrvEAJIajxW4B8UvaN3N1XrWwquxoj2Rf +xX2CXk9kvD4tyEZfkfscqhHFkzdRs+Rjky/bVg9DkLURUzjsRFzmZS2Xk7RkgDMS +KBeuux4/K8cZ/oc= +=ij+U +-----END PGP PUBLIC KEY BLOCK----- diff --git a/SOURCES/orc-1.6.6.tar.gz.asc b/SOURCES/orc-1.6.6.tar.gz.asc new file mode 100644 index 0000000..a5dca06 --- /dev/null +++ b/SOURCES/orc-1.6.6.tar.gz.asc @@ -0,0 +1,16 @@ +-----BEGIN PGP SIGNATURE----- + +iQIzBAABCgAdFiEE8oycklwYjDXjRWFN7aAM6DTw/FwFAl/JV7cACgkQ7aAM6DTw +/FwflBAAvUZep3tR8V2DOooqGRXhj5OncKtPfV8iOFntvfYXy+8Mxb+8lV7WsmFd +rUzcHVu9Zx2RK89nhm8oXrG5L2sRNQRNcW/+VBhwgn66+p1a0RO/gIUur1Ge5BBT +usQ3njG/jLKyf0LWfWR3P/RZzQbUGNUg8dOME+2Kr1dItK25DiJC3X0/a6yDy7Rq +mDVPdXftGQF2Wp8F4zhv+kcyKiTfnIkCfYi2LAhFgEgKQLcU9H0EQGWyFD7suJV3 +7a91AX0kVCgGAOCH6XwV+KG47tnfKa1ut16kdC9IdgvdwcCLvSfmdY1B9ViO1Dg0 +f7TgKp1JJ24dYxDrk4XbYmAwwPqchfAD0qia45g6UaGdopO5GDA+YPD/mcGn2pnV +7sAck/js4nyYQii2+vFpTiwr6/N/eYzwH93CBMW9j6CdjGcKzkxi4p21L3al2tdi +cv1aP5NJ98RlV3H9Lp4ob+bsQJRmclWmt5vfLmASUkN6fGvdZ7pEdUwsjNRriwaN +T3Q9KWIvTjcjwWL126lHNoPS9xbbroon+Qk+zGJVXGhtjv79dQVzYTRYE3FK7eTI +V2heVmUAdik4Zt6h77yLocq2e5yMaxbgtsJXJR4CcBdfxn+ESSMSvXyJTaH0SH+s +zmF9IoaY4OaOYjtnBrR4CI/wb+cY7+dCRlRF28y5KUH5p2fH6DU= +=ZVxa +-----END PGP SIGNATURE----- diff --git a/SOURCES/orc-1.6.6.tar.gz.sha256 b/SOURCES/orc-1.6.6.tar.gz.sha256 new file mode 100644 index 0000000..3b1bb8b --- /dev/null +++ b/SOURCES/orc-1.6.6.tar.gz.sha256 @@ -0,0 +1 @@ +93d2e5f7c9f76ea5cdf29073c73a00a37c54281a5c02bcc6395f1cf521ea246c orc-1.6.6.tar.gz diff --git a/SPECS/liborc.spec b/SPECS/liborc.spec new file mode 100644 index 0000000..3025a11 --- /dev/null +++ b/SPECS/liborc.spec @@ -0,0 +1,105 @@ +Summary: Library for producing small, fast columnar storage for Hadoop workloads +Name: liborc +Version: 1.6.6 +Release: 2%{?dist} +License: ASL 2.0 +URL: http://orc.apache.org/ +Source: https://archive.apache.org/dist/orc/orc-%{version}/orc-%{version}.tar.gz +Patch1: 0001-cmake.patch +# Apache ORC has numerous compile errors and apparently assumes a 64-bit +# build and runtime environment. The only consumer of this package is +# Ceph (by way of Apache Arrow) which is also 64-bit only +ExcludeArch: i686 armv7hl +BuildRequires: gnupg2 +BuildRequires: cmake +BuildRequires: gcc-c++ +BuildRequires: protobuf-devel +BuildRequires: zlib-devel +BuildRequires: libzstd-devel +BuildRequires: lz4-devel +BuildRequires: snappy-devel + +%global debug_package %{nil} + +%description +ORC is a self-describing type-aware columnar file format designed +for Hadoop workloads. It is optimized for large streaming reads, +but with integrated support for finding required rows quickly. +Storing data in a columnar format lets the reader read, decompress, +and process only the values that are required for the current query. +Because ORC files are type-aware, the writer chooses the most +appropriate encoding for the type and builds an internal index as +the file is written. Predicate pushdown uses those indexes to +determine which stripes in a file need to be read for a particular +query and the row indexes can narrow the search to a particular set +of 10,000 rows. ORC supports the complete set of types in Hive, +including the complex types: structs, lists, maps, and unions. + +%package -n liborc1 +Summary: Library for producing small, fast columnar storage for Hadoop workloads + +%description -n liborc1 +Contains %{name} libraries for applications that use Apache ORC. + +%package devel +Summary: Header files, libraries and development documentation for %{name} +Requires: %{name}1%{?_isa} = %{version}-%{release} + +%description devel +Contains header files for developing applications that use the %{name} +library. + +%prep +%setup -qn orc-rel-release-%{version} +%patch1 -p1 -b .orig + +%build +%cmake . \ + -DOVERRIDE_INSTALL_PREFIX=/usr \ + -DCMAKE_COLOR_MAKEFILE:BOOL=OFF \ + -DCMAKE_INSTALL_LIBDIR:PATH=%{_libdir} \ + -DINSTALL_LIBDIR:PATH=%{_libdir} \ + -DBUILD_SHARED_LIBS:BOOL=on \ + -DBUILD_LIBHDFSPP:BOOL=off \ + -DSNAPPY_HOME="/usr" \ + -DLZ4_HOME="/usr" \ + -DZLIB_HOME="/usr" \ + -DZSTD_HOME="/usr" \ + -DGTEST_HOME="/usr" \ + -DPROTOBUF_HOME="/usr" \ + -Dorc_VERSION="%{version}" \ + -DBUILD_CPP_TESTS=off \ + -DBUILD_TOOLS=off \ + -DBUILD_JAVA=off \ + -DANALYZE_JAVA=off \ + "-GUnix Makefiles" +%cmake_build + +%check + +%install +%cmake_install +mkdir %{buildroot}%{_docdir}/%{name}1 +mv %{buildroot}%{_docdir}/orc/NOTICE %{buildroot}%{_docdir}/%{name}1/ +mkdir -p %{buildroot}/%{_defaultlicensedir}/%{name}1 +mv %{buildroot}%{_docdir}/orc/LICENSE %{buildroot}/%{_defaultlicensedir}/%{name}1/ + +%ldconfig_scriptlets + +%files -n %{name}1 +%license LICENSE +%doc README.md NOTICE +%{_libdir}/liborc.so.* + +%files devel +%{_includedir}/orc/*.hh +%{_libdir}/liborc.so +%{_libdir}/cmake/orc/orc*.cmake + +%changelog +* Thu Jan 14 2022 Kaleb S. KEITHLEY - 1.6.6-2 +- rebuild from lookaside + +* Fri Aug 27 2021 Kaleb S. KEITHLEY - 1.6.6-1 +- New upstream release. +