From 721389d2d1f43a58eebe551154b7c06d32e6236e Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Sat, 16 May 2015 17:52:06 -0400 Subject: [PATCH 01/49] librest libdropbox and libgdrive in cmake --- .gitignore | 1 + CMakeLists.txt | 7 +++++++ libgdrive/CMakeLists.txt | 2 ++ librest/CMakeLists.txt | 2 ++ src/CMakeLists.txt | 4 ++++ src/os.h | 2 +- 6 files changed, 17 insertions(+), 1 deletion(-) create mode 100644 CMakeLists.txt create mode 100644 libgdrive/CMakeLists.txt create mode 100644 librest/CMakeLists.txt create mode 100644 src/CMakeLists.txt diff --git a/.gitignore b/.gitignore index 78a23ef..c844b07 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,4 @@ +build/ *.orig *.swp *.bak diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..1aad74e --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,7 @@ +cmake_minimum_required (VERSION 2.6) +project (Syncd) + +include_directories("${CMAKE_CURRENT_LIST_DIR}") +add_subdirectory(librest) +add_subdirectory(libdropbox) +add_subdirectory(libgdrive) diff --git a/libgdrive/CMakeLists.txt b/libgdrive/CMakeLists.txt new file mode 100644 index 0000000..6375cb1 --- /dev/null +++ b/libgdrive/CMakeLists.txt @@ -0,0 +1,2 @@ +add_library(libdgrive gdrive_api.c) +target_link_libraries(libdgrive LINK_PUBLIC librest json-c) diff --git a/librest/CMakeLists.txt b/librest/CMakeLists.txt new file mode 100644 index 0000000..bc67a71 --- /dev/null +++ b/librest/CMakeLists.txt @@ -0,0 +1,2 @@ +add_library(librest rest.c buffer.c) +target_link_libraries(librest LINK_PUBLIC curl) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt new file mode 100644 index 0000000..1c1004f --- /dev/null +++ b/src/CMakeLists.txt @@ -0,0 +1,4 @@ +include_directories("${CMAKE_ROOT}") +include_directories("${CMAKE_CURRENT_LIST_DIR}") +add_executable(syncd syncd.c cache.c ipc_semaphore.c shared_memory.c json_helper.c log.c os.h plugin.h) + diff --git a/src/os.h b/src/os.h index c24c519..ba4593a 100644 --- a/src/os.h +++ b/src/os.h @@ -28,7 +28,7 @@ #include #include #include "cache.h" -#include +//#include #ifndef HAVE_FORK #define fork() pseudo_fork(i,argv[0]) From 2ae369ad37c3d3df2834d135ce385d4a41077771 Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Sat, 16 May 2015 21:34:37 -0400 Subject: [PATCH 02/49] working build except for inotify --- CMakeLists.txt | 2 ++ libexec/CMakeLists.txt | 8 ++++++++ libexec/syncfs.c | 9 +++++---- libgdrive/CMakeLists.txt | 5 +++-- libgdrive/gdrive_api.c | 4 ++-- librest/CMakeLists.txt | 5 +++-- src/CMakeLists.txt | 2 +- src/log.c | 3 +++ src/os.h | 2 +- src/syncd.c | 6 +++++- 10 files changed, 33 insertions(+), 13 deletions(-) create mode 100644 libexec/CMakeLists.txt diff --git a/CMakeLists.txt b/CMakeLists.txt index 1aad74e..343d901 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -5,3 +5,5 @@ include_directories("${CMAKE_CURRENT_LIST_DIR}") add_subdirectory(librest) add_subdirectory(libdropbox) add_subdirectory(libgdrive) +add_subdirectory(libexec) +add_subdirectory(src) diff --git a/libexec/CMakeLists.txt b/libexec/CMakeLists.txt new file mode 100644 index 0000000..8afa110 --- /dev/null +++ b/libexec/CMakeLists.txt @@ -0,0 +1,8 @@ +add_library(syncFile MODULE syncfs.c) + +add_library(syncDrobBox MODULE dropbox.c) +target_link_libraries(syncDrobBox LINK_PRIVATE dropbox) + +add_library(syncGoogleDrive MODULE gdrive.c gdrive_cache.c) +target_link_libraries(syncGoogleDrive LINK_PRIVATE gdrive) + diff --git a/libexec/syncfs.c b/libexec/syncfs.c index 621ce47..9c1b9d7 100644 --- a/libexec/syncfs.c +++ b/libexec/syncfs.c @@ -36,24 +36,25 @@ #define PLUGIN_PREFIX_LEN 7 #include - +#define HAVE_INOTIFY_H char* init(init_args); void add_watch(char *); void watch_dir(char *); void sync_listen(int(*)(const char*,int)); +int sync_mkdir(char*); int update_file_cache(char*,int); int(*update_event)(const char*,int); init_args args; -#ifdef HAVE_CONFIG_H -# include +//#ifdef HAVE_CONFIG_H +//# include #ifdef HAVE_INOTIFY_H # include "linuxfs.c" # else # include "uvfs.c" # endif -#endif +//#endif FILE ** open_files; diff --git a/libgdrive/CMakeLists.txt b/libgdrive/CMakeLists.txt index 6375cb1..a3ffe83 100644 --- a/libgdrive/CMakeLists.txt +++ b/libgdrive/CMakeLists.txt @@ -1,2 +1,3 @@ -add_library(libdgrive gdrive_api.c) -target_link_libraries(libdgrive LINK_PUBLIC librest json-c) +add_library(gdrive gdrive_api.c) +set_property(TARGET gdrive PROPERTY POSITION_INDEPENDENT_CODE ON) +target_link_libraries(gdrive LINK_PRIVATE rest json-c) diff --git a/libgdrive/gdrive_api.c b/libgdrive/gdrive_api.c index 77e513a..a6172f8 100644 --- a/libgdrive/gdrive_api.c +++ b/libgdrive/gdrive_api.c @@ -35,7 +35,7 @@ bool JSON_GET_BOOL(json_object * obj, const char * object, bool def){ return def; } -char * safe_strdup(const char * in){ +char * _safe_strdup(const char * in){ if (in == NULL) return NULL; return strdup(in); } @@ -78,7 +78,7 @@ json_object * gdrive_get_metadata(const char * file_id){ FILE * gdrive_get (const char * file_id){ json_object * metadata = gdrive_get_metadata(file_id); - char * download_url = safe_strdup(JSON_GET_STRING(metadata,"downloadUrl")); + char * download_url = _safe_strdup(JSON_GET_STRING(metadata,"downloadUrl")); if (download_url == NULL) return NULL; download_url = (char*)realloc(download_url, strlen(download_url) diff --git a/librest/CMakeLists.txt b/librest/CMakeLists.txt index bc67a71..f3bc7d7 100644 --- a/librest/CMakeLists.txt +++ b/librest/CMakeLists.txt @@ -1,2 +1,3 @@ -add_library(librest rest.c buffer.c) -target_link_libraries(librest LINK_PUBLIC curl) +add_library(rest rest.c buffer.c) +set_property(TARGET rest PROPERTY POSITION_INDEPENDENT_CODE ON) +target_link_libraries(rest LINK_PUBLIC curl) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 1c1004f..c7283b4 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -1,4 +1,4 @@ -include_directories("${CMAKE_ROOT}") include_directories("${CMAKE_CURRENT_LIST_DIR}") add_executable(syncd syncd.c cache.c ipc_semaphore.c shared_memory.c json_helper.c log.c os.h plugin.h) +target_link_libraries(syncd LINK_PUBLIC json-c ltdl rt pthread) diff --git a/src/log.c b/src/log.c index 337770f..cf50283 100644 --- a/src/log.c +++ b/src/log.c @@ -1,4 +1,7 @@ #include "log.h" +#include +#define _GNU_SOURCE +#include #include #include diff --git a/src/os.h b/src/os.h index ba4593a..f8e14c2 100644 --- a/src/os.h +++ b/src/os.h @@ -29,7 +29,7 @@ #include #include "cache.h" //#include - +#define HAVE_FORK #ifndef HAVE_FORK #define fork() pseudo_fork(i,argv[0]) int pseudo_fork(int plugin_num,char * exec_name){ diff --git a/src/syncd.c b/src/syncd.c index 2b3e970..7a8e6b7 100644 --- a/src/syncd.c +++ b/src/syncd.c @@ -28,6 +28,10 @@ #include #include "log.h" +#ifndef LIBDIR +#define LIBDIR "/usr/local/lib/syncd" +#endif + typedef struct { lt_dlhandle ptr; const char * prefix; @@ -176,7 +180,7 @@ int cb(const char * path, int mask){ lt_dlhandle loadPlugin(const char * filename ){ const char * ext = rindex(filename, '.'); - if(strcmp(ext, ".la") != 0) return NULL; + if(strcmp(ext, ".so") != 0) return NULL; lt_dlhandle out = lt_dlopen(filename); const char * (*get_prefix)() = (const char * (*)()) lt_dlsym (out, "get_prefix"); if ( get_prefix != NULL){ From 5f7bb319a726c4e4aff6718eecce29ea17cb6927 Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Tue, 26 May 2015 23:48:43 -0400 Subject: [PATCH 03/49] mostly working --- .cmake-modules/FindCURL.cmake | 75 +++++ .cmake-modules/FindJSONC.cmake | 75 +++++ .cmake-modules/FindLTDL.cmake | 75 +++++ .cmake-modules/FindMMAN.cmake | 75 +++++ .cmake-modules/FindUV.cmake | 75 +++++ CMakeLists.txt | 19 ++ autogen.sh | 0 cmake-config.h.in | 4 + libexec/CMakeLists.txt | 24 +- libexec/dropbox.c | 51 +-- libexec/dropbox.h | 43 +++ libexec/gdrive.c | 56 ++-- libexec/gdrive.h | 45 +++ libexec/strptime.c | 560 +++++++++++++++++++++++++++++++++ libexec/strptime.h | 7 + libexec/syncfs.c | 46 +-- libexec/syncfs.h | 41 +++ libexec/uvfs.c | 6 +- libgdrive/CMakeLists.txt | 4 +- libgdrive/gdrive_api.c | 4 +- librest/CMakeLists.txt | 6 +- librest/Makefile.old | 22 +- src/CMakeLists.txt | 13 +- src/cache.c | 10 +- src/cache.h | 1 - src/log.c | 32 +- src/os.h | 13 +- src/plugin.c | 22 +- src/plugin.h | 45 +-- src/plugins.h | 16 + src/syncd.c | 58 +++- src/test | Bin 0 -> 162601 bytes src/test.exe | Bin 0 -> 162601 bytes src/testPlugin.c | 48 +++ 34 files changed, 1357 insertions(+), 214 deletions(-) create mode 100644 .cmake-modules/FindCURL.cmake create mode 100644 .cmake-modules/FindJSONC.cmake create mode 100644 .cmake-modules/FindLTDL.cmake create mode 100644 .cmake-modules/FindMMAN.cmake create mode 100644 .cmake-modules/FindUV.cmake mode change 100755 => 100644 autogen.sh create mode 100644 cmake-config.h.in create mode 100644 libexec/dropbox.h create mode 100644 libexec/gdrive.h create mode 100644 libexec/strptime.c create mode 100644 libexec/strptime.h create mode 100644 libexec/syncfs.h create mode 100644 src/plugins.h create mode 100644 src/test create mode 100644 src/test.exe create mode 100644 src/testPlugin.c diff --git a/.cmake-modules/FindCURL.cmake b/.cmake-modules/FindCURL.cmake new file mode 100644 index 0000000..d2e7b08 --- /dev/null +++ b/.cmake-modules/FindCURL.cmake @@ -0,0 +1,75 @@ +# - Find curl +# Find the native CURL headers and libraries. +# +# CURL_INCLUDE_DIRS - where to find curl/curl.h, etc. +# CURL_LIBRARIES - List of libraries when using curl. +# CURL_FOUND - True if curl found. + +# Look for the header file. +FIND_PATH(CURL_INCLUDE_DIR curl/curl.h + $ENV{INCLUDE} + "$ENV{LIB_DIR}/include" + /usr/local/include + /usr/include + #mingw + c:/msys/include + c:/msys/bin + /usr/x86_64-w64-mingw32/include + /usr/i686-w64-mingw32/include + NO_DEFAULT_PATH + ) + +MARK_AS_ADVANCED(CURL_INCLUDE_DIR) + +# Look for the library. +FIND_LIBRARY(CURL_LIBRARY NAMES curl libcurl_imp PATHS + $ENV{LIB} + "$ENV{LIB_DIR}/lib" + /usr/local/lib + /usr/lib + c:/msys/lib + /usr/x86_64-w64-mingw32/lib + /usr/i686-w64-mingw32/lib + NO_DEFAULT_PATH + ) + +MARK_AS_ADVANCED(CURL_LIBRARY) + +IF(CURL_INCLUDE_DIR) + MESSAGE(STATUS "Curl include was found") +ENDIF(CURL_INCLUDE_DIR) +IF(CURL_LIBRARY) + MESSAGE(STATUS "Curl lib was found") +ENDIF(CURL_LIBRARY) + +# Copy the results to the output variables. +IF(CURL_INCLUDE_DIR AND CURL_LIBRARY) + SET(CURL_FOUND 1) + SET(CURL_LIBRARIES ${CURL_LIBRARY}) + SET(CURL_INCLUDE_DIRS ${CURL_INCLUDE_DIR}) +ELSE(CURL_INCLUDE_DIR AND CURL_LIBRARY) + SET(CURL_FOUND 0) + SET(CURL_LIBRARIES) + SET(CURL_INCLUDE_DIRS) +ENDIF(CURL_INCLUDE_DIR AND CURL_LIBRARY) + +# Report the results. +IF(CURL_FOUND) + IF (NOT CURL_FIND_QUIETLY) + MESSAGE(STATUS "Found CURL: ${CURL_LIBRARY}") + ENDIF (NOT CURL_FIND_QUIETLY) +ELSE(CURL_FOUND) + SET(CURL_DIR_MESSAGE "CURL was not found.") + + IF(CURL_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "${CURL_DIR_MESSAGE}") + ELSE(CURL_FIND_REQUIRED) + IF(NOT CURL_FIND_QUIETLY) + MESSAGE(STATUS "${CURL_DIR_MESSAGE}") + ENDIF(NOT CURL_FIND_QUIETLY) + # Avoid cmake complaints if CURL is not found + SET(CURL_INCLUDE_DIR "") + SET(CURL_LIBRARY "") + ENDIF(CURL_FIND_REQUIRED) + +ENDIF(CURL_FOUND) diff --git a/.cmake-modules/FindJSONC.cmake b/.cmake-modules/FindJSONC.cmake new file mode 100644 index 0000000..a2e59d9 --- /dev/null +++ b/.cmake-modules/FindJSONC.cmake @@ -0,0 +1,75 @@ +# - Find json-c +# Find the native JSONC headers and libraries. +# +# JSONC_INCLUDE_DIRS - where to find curl/curl.h, etc. +# JSONC_LIBRARIES - List of libraries when using curl. +# JSONC_FOUND - True if curl found. + +# Look for the header file. +FIND_PATH(JSONC_INCLUDE_DIR json-c/json.h + $ENV{INCLUDE} + "$ENV{LIB_DIR}/include" + /usr/local/include + /usr/include + #mingw + c:/msys/include + /usr/x86_64-w64-mingw32/include + /usr/i686-w64-mingw32/include + NO_DEFAULT_PATH + ) + +MARK_AS_ADVANCED(JSONC_INCLUDE_DIR) + +# Look for the library. +FIND_LIBRARY(JSONC_LIBRARY NAMES json-c libjson-c PATHS + $ENV{LIB} + $ENV{PATH} + "$ENV{LIB_DIR}/lib" + /usr/local/lib + /usr/lib + c:/msys/lib + /usr/x86_64-w64-mingw32/lib + /usr/i686-w64-mingw32/lib + NO_DEFAULT_PATH + ) + +MARK_AS_ADVANCED(JSONC_LIBRARY) + +IF(JSONC_INCLUDE_DIR) + MESSAGE(STATUS "json-c include was found") +ENDIF(JSONC_INCLUDE_DIR) +IF(JSONC_LIBRARY) + MESSAGE(STATUS "json-c lib was found") +ENDIF(JSONC_LIBRARY) + +# Copy the results to the output variables. +IF(JSONC_INCLUDE_DIR AND JSONC_LIBRARY) + SET(JSONC_FOUND 1) + SET(JSONC_LIBRARIES ${JSONC_LIBRARY}) + SET(JSONC_INCLUDE_DIRS ${JSONC_INCLUDE_DIR}) +ELSE(JSONC_INCLUDE_DIR AND JSONC_LIBRARY) + SET(JSONC_FOUND 0) + SET(JSONC_LIBRARIES) + SET(JSONC_INCLUDE_DIRS) +ENDIF(JSONC_INCLUDE_DIR AND JSONC_LIBRARY) + +# Report the results. +IF(JSONC_FOUND) + IF (NOT JSONC_FIND_QUIETLY) + MESSAGE(STATUS "Found json-c: ${JSONC_LIBRARY}") + ENDIF (NOT JSONC_FIND_QUIETLY) +ELSE(JSONC_FOUND) + SET(JSONC_DIR_MESSAGE "json-c was not found.") + + IF(JSONC_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "${JSONC_DIR_MESSAGE}") + ELSE(JSONC_FIND_REQUIRED) + IF(NOT JSONC_FIND_QUIETLY) + MESSAGE(STATUS "${JSONC_DIR_MESSAGE}") + ENDIF(NOT JSONC_FIND_QUIETLY) + # Avoid cmake complaints if JSONC is not found + SET(JSONC_INCLUDE_DIR "") + SET(JSONC_LIBRARY "") + ENDIF(JSONC_FIND_REQUIRED) + +ENDIF(JSONC_FOUND) diff --git a/.cmake-modules/FindLTDL.cmake b/.cmake-modules/FindLTDL.cmake new file mode 100644 index 0000000..9f0402f --- /dev/null +++ b/.cmake-modules/FindLTDL.cmake @@ -0,0 +1,75 @@ +# - Find libltdl +# Find the native UV headers and libraries. +# +# LTDL_INCLUDE_DIRS - where to find ltdl.h, etc. +# LTDL_LIBRARIES - List of libraries when using curl. +# LTDL_FOUND - True if curl found. + +# Look for the header file. +FIND_PATH(LTDL_INCLUDE_DIR ltdl.h + $ENV{INCLUDE} + "$ENV{LIB_DIR}/include" + /usr/local/include + /usr/include + #mingw + c:/msys/include + /usr/x86_64-w64-mingw32/include + /usr/i686-w64-mingw32/include + NO_DEFAULT_PATH + ) + +MARK_AS_ADVANCED(LTDL_INCLUDE_DIR) + +# Look for the library. +FIND_LIBRARY(LTDL_LIBRARY NAMES ltdl libltdl PATHS + $ENV{LIB} + "$ENV{LIB_DIR}/lib" + /usr/local/lib + /usr/lib + c:/msys/lib + c:/msys/bin + /usr/x86_64-w64-mingw32/lib + /usr/i686-w64-mingw32/lib + NO_DEFAULT_PATH + ) + +MARK_AS_ADVANCED(LTDL_LIBRARY) + +IF(LTDL_INCLUDE_DIR) + MESSAGE(STATUS "libltdl include was found") +ENDIF(LTDL_INCLUDE_DIR) +IF(LTDL_LIBRARY) + MESSAGE(STATUS "libltdl lib was found") +ENDIF(LTDL_LIBRARY) + +# Copy the results to the output variables. +IF(LTDL_INCLUDE_DIR AND LTDL_LIBRARY) + SET(LTDL_FOUND 1) + SET(LTDL_LIBRARIES ${LTDL_LIBRARY}) + SET(LTDL_INCLUDE_DIRS ${LTDL_INCLUDE_DIR}) +ELSE(LTDL_INCLUDE_DIR AND LTDL_LIBRARY) + SET(LTDL_FOUND 0) + SET(LTDL_LIBRARIES) + SET(LTDL_INCLUDE_DIRS) +ENDIF(LTDL_INCLUDE_DIR AND LTDL_LIBRARY) + +# Report the results. +IF(LTDL_FOUND) + IF (NOT LTDL_FIND_QUIETLY) + MESSAGE(STATUS "Found libltdl: ${LTDL_LIBRARY}") + ENDIF (NOT LTDL_FIND_QUIETLY) +ELSE(LTDL_FOUND) + SET(LTDL_DIR_MESSAGE "libltdl was not found.") + + IF(LTDL_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "${LTDL_DIR_MESSAGE}") + ELSE(LTDL_FIND_REQUIRED) + IF(NOT LTDL_FIND_QUIETLY) + MESSAGE(STATUS "${LTDL_DIR_MESSAGE}") + ENDIF(NOT LTDL_FIND_QUIETLY) + # Avoid cmake complaints if UV is not found + SET(LTDL_INCLUDE_DIR "") + SET(LTDL_LIBRARY "") + ENDIF(LTDL_FIND_REQUIRED) + +ENDIF(LTDL_FOUND) diff --git a/.cmake-modules/FindMMAN.cmake b/.cmake-modules/FindMMAN.cmake new file mode 100644 index 0000000..1a4e765 --- /dev/null +++ b/.cmake-modules/FindMMAN.cmake @@ -0,0 +1,75 @@ +# - Find libmman +# Find the native MMAN headers and libraries. +# +# MMAN_INCLUDE_DIRS - where to find MMAN.h, etc. +# MMAN_LIBRARIES - List of libraries when using curl. +# MMAN_FOUND - True if curl found. + +# Look for the header file. +FIND_PATH(MMAN_INCLUDE_DIR sys/mman.h + $ENV{INCLUDE} + "$ENV{LIB_DIR}/include" + /usr/local/include + /usr/include + #mingw + c:/msys/include + /usr/x86_64-w64-mingw32/include + /usr/i686-w64-mingw32/include + NO_DEFAULT_PATH + ) + +MARK_AS_ADVANCED(MMAN_INCLUDE_DIR) + +# Look for the library. +FIND_LIBRARY(MMAN_LIBRARY NAMES mman libmman PATHS + $ENV{LIB} + "$ENV{LIB_DIR}/lib" + /usr/local/lib + /usr/lib + c:/msys/lib + c:/msys/bin + /usr/x86_64-w64-mingw32/lib + /usr/i686-w64-mingw32/lib + NO_DEFAULT_PATH + ) + +MARK_AS_ADVANCED(MMAN_LIBRARY) + +IF(MMAN_INCLUDE_DIR) + MESSAGE(STATUS "libmman include was found") +ENDIF(MMAN_INCLUDE_DIR) +IF(MMAN_LIBRARY) + MESSAGE(STATUS "libmman lib was found") +ENDIF(MMAN_LIBRARY) + +# Copy the results to the output variables. +IF(MMAN_INCLUDE_DIR AND MMAN_LIBRARY) + SET(MMAN_FOUND 1) + SET(MMAN_LIBRARIES ${MMAN_LIBRARY}) + SET(MMAN_INCLUDE_DIRS ${MMAN_INCLUDE_DIR}) +ELSE(MMAN_INCLUDE_DIR AND MMAN_LIBRARY) + SET(MMAN_FOUND 0) + SET(MMAN_LIBRARIES) + SET(MMAN_INCLUDE_DIRS) +ENDIF(MMAN_INCLUDE_DIR AND MMAN_LIBRARY) + +# Report the results. +IF(MMAN_FOUND) + IF (NOT MMAN_FIND_QUIETLY) + MESSAGE(STATUS "Found libmman: ${MMAN_LIBRARY}") + ENDIF (NOT MMAN_FIND_QUIETLY) +ELSE(MMAN_FOUND) + SET(MMAN_DIR_MESSAGE "libmman was not found.") + + IF(MMAN_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "${MMAN_DIR_MESSAGE}") + ELSE(MMAN_FIND_REQUIRED) + IF(NOT MMAN_FIND_QUIETLY) + MESSAGE(STATUS "${MMAN_DIR_MESSAGE}") + ENDIF(NOT MMAN_FIND_QUIETLY) + # Avoid cmake complaints if UV is not found + SET(MMAN_INCLUDE_DIR "") + SET(MMAN_LIBRARY "") + ENDIF(MMAN_FIND_REQUIRED) + +ENDIF(MMAN_FOUND) diff --git a/.cmake-modules/FindUV.cmake b/.cmake-modules/FindUV.cmake new file mode 100644 index 0000000..a61b01f --- /dev/null +++ b/.cmake-modules/FindUV.cmake @@ -0,0 +1,75 @@ +# - Find libuv +# Find the native UV headers and libraries. +# +# UV_INCLUDE_DIRS - where to find curl/curl.h, etc. +# UV_LIBRARIES - List of libraries when using curl. +# UV_FOUND - True if curl found. + +# Look for the header file. +FIND_PATH(UV_INCLUDE_DIR uv.h + $ENV{INCLUDE} + "$ENV{LIB_DIR}/include" + /usr/local/include + /usr/include + #mingw + c:/msys/include + /usr/x86_64-w64-mingw32/include + /usr/i686-w64-mingw32/include + NO_DEFAULT_PATH + ) + +MARK_AS_ADVANCED(UV_INCLUDE_DIR) + +# Look for the library. +FIND_LIBRARY(UV_LIBRARY NAMES uv libuv PATHS + $ENV{LIB} + "$ENV{LIB_DIR}/lib" + /usr/local/lib + /usr/lib + c:/msys/lib + c:/msys/bin + /usr/x86_64-w64-mingw32/lib + /usr/i686-w64-mingw32/lib + NO_DEFAULT_PATH + ) + +MARK_AS_ADVANCED(UV_LIBRARY) + +IF(UV_INCLUDE_DIR) + MESSAGE(STATUS "libuv include was found") +ENDIF(UV_INCLUDE_DIR) +IF(UV_LIBRARY) + MESSAGE(STATUS "libuv lib was found") +ENDIF(UV_LIBRARY) + +# Copy the results to the output variables. +IF(UV_INCLUDE_DIR AND UV_LIBRARY) + SET(UV_FOUND 1) + SET(UV_LIBRARIES ${UV_LIBRARY}) + SET(UV_INCLUDE_DIRS ${UV_INCLUDE_DIR}) +ELSE(UV_INCLUDE_DIR AND UV_LIBRARY) + SET(UV_FOUND 0) + SET(UV_LIBRARIES) + SET(UV_INCLUDE_DIRS) +ENDIF(UV_INCLUDE_DIR AND UV_LIBRARY) + +# Report the results. +IF(UV_FOUND) + IF (NOT UV_FIND_QUIETLY) + MESSAGE(STATUS "Found libuv: ${UV_LIBRARY}") + ENDIF (NOT UV_FIND_QUIETLY) +ELSE(UV_FOUND) + SET(UV_DIR_MESSAGE "libuv was not found.") + + IF(UV_FIND_REQUIRED) + MESSAGE(FATAL_ERROR "${UV_DIR_MESSAGE}") + ELSE(UV_FIND_REQUIRED) + IF(NOT UV_FIND_QUIETLY) + MESSAGE(STATUS "${UV_DIR_MESSAGE}") + ENDIF(NOT UV_FIND_QUIETLY) + # Avoid cmake complaints if UV is not found + SET(UV_INCLUDE_DIR "") + SET(UV_LIBRARY "") + ENDIF(UV_FIND_REQUIRED) + +ENDIF(UV_FOUND) diff --git a/CMakeLists.txt b/CMakeLists.txt index 343d901..c788f80 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,9 +1,28 @@ cmake_minimum_required (VERSION 2.6) project (Syncd) +# Include findPackage and findHeader +set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/.cmake-modules") +include(CheckIncludeFiles) +include(CheckFunctionExists) + +find_package(JSONC) +find_package(THREADS) + +include_directories(${JSONC_INCLUDE_DIRS}) + +check_include_files("inotify.h" HAVE_INOTIFY_H) +check_include_files("err.h" HAVE_ERR_H) +check_include_files("sys/wait.h" HAVE_WAIT_H) +check_function_exists(fork HAVE_FORK) + +include_directories("${CMAKE_BINARY_DIR}") + include_directories("${CMAKE_CURRENT_LIST_DIR}") add_subdirectory(librest) add_subdirectory(libdropbox) add_subdirectory(libgdrive) add_subdirectory(libexec) add_subdirectory(src) + +CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/cmake-config.h.in ${CMAKE_CURRENT_BINARY_DIR}/config.h) \ No newline at end of file diff --git a/autogen.sh b/autogen.sh old mode 100755 new mode 100644 diff --git a/cmake-config.h.in b/cmake-config.h.in new file mode 100644 index 0000000..6c68637 --- /dev/null +++ b/cmake-config.h.in @@ -0,0 +1,4 @@ +#cmakedefine HAVE_INOTIFY_H 1 +#cmakedefine HAVE_ERR_H 1 +#cmakedefine HAVE_FORK 1 +#cmakedefine HAVE_WAIT_H 1 diff --git a/libexec/CMakeLists.txt b/libexec/CMakeLists.txt index 8afa110..a212cf2 100644 --- a/libexec/CMakeLists.txt +++ b/libexec/CMakeLists.txt @@ -1,8 +1,24 @@ -add_library(syncFile MODULE syncfs.c) +Message("libjson ${JSONC_LIBRARIES}") +if(HAVE_INOTIFY_H) + Message("Using Inotify for FileSystem events.") + add_library(syncFile MODULE syncfs.c linuxfs.c ../src/plugin.c ../src/json_helper.c) + target_link_libraries(syncFile LINK_PRIVATE ${JSONC_LIBRARIES}) +else() + find_package(UV REQUIRED) + if (UV_FOUND) + Message("Using libuv for FileSystem events.") + add_library(syncFile MODULE syncfs.c uvfs.c ../src/plugin.c ../src/json_helper.c) + target_link_libraries(syncFile LINK_PRIVATE ${JSONC_LIBRARIES}) + target_link_libraries(syncFile LINK_PRIVATE ${UV_LIBRARIES}) + endif() +endif() -add_library(syncDrobBox MODULE dropbox.c) +if(WIN32) + set (COMPAT ${COMPAT} "strptime.c") +endif() + +add_library(syncDrobBox MODULE dropbox.c ${COMPAT} ../src/plugin.c ../src/json_helper.c) target_link_libraries(syncDrobBox LINK_PRIVATE dropbox) -add_library(syncGoogleDrive MODULE gdrive.c gdrive_cache.c) +add_library(syncGoogleDrive MODULE gdrive.c ${COMPAT} gdrive_cache.c ../src/plugin.c ../src/json_helper.c) target_link_libraries(syncGoogleDrive LINK_PRIVATE gdrive) - diff --git a/libexec/dropbox.c b/libexec/dropbox.c index 34ad207..0458cbf 100644 --- a/libexec/dropbox.c +++ b/libexec/dropbox.c @@ -19,32 +19,7 @@ * THE SOFTWARE. */ -#define _XOPEN_SOURCE 500 -#include -#include -#include -#include -#include -#include -#include -#include "../libdropbox/dropbox_api.h" - -#define PLUGIN_PREFIX "dropbox://" -#define PLUGIN_PREFIX_LEN 10 // i counted -#include - - -#if defined(_WIN32) -#define URL_OPEN_CMD "start \"\"" -#define SILENT_CMD "" -#elif defined(__APPLE__) && defined(__MACH__) -#define URL_OPEN_CMD "open" -#define SILENT_CMD "" -#else -#define URL_OPEN_CMD "sh -c 'xdg-open" -#define SILENT_CMD "' >/dev/null 2&>/dev/null" -#endif - +#include "dropbox.h" /* globals */ char * client_key = "gmq6fs74fuw1ead"; char * client_secret = "ia87pt0ep6dvb7y"; @@ -54,6 +29,12 @@ utilities utils; json_object * config; json_object * cache; +#ifndef HAVE_WARN_H + int WEXITSTATUS(int in){ + args.log(LOGARGS, "COMPAT_WEXITSTATUS in=%d, %x", in,in ); + return in; + } +#endif /* convenience functions */ const char * JSON_GET_STRING(json_object * obj, char * object){ if (json_object_object_get_ex(obj,object,&obj)){ @@ -131,7 +112,7 @@ const char * get_prefix(){ return PLUGIN_PREFIX; } -char * init(init_args a){ +const char * init(init_args a){ args = a; utils = args.utils; curl_global_init(CURL_GLOBAL_DEFAULT); @@ -146,14 +127,14 @@ char * init(init_args a){ char cmd[512]; sprintf(cmd, "%s \"%s?response_type=code&client_id=%s\" %s",URL_OPEN_CMD,OAUTH_2_AUTH,client_key, SILENT_CMD); //printf("go to https://www.dropbox.com/1/oauth2/authorize?response_type=code&client_id=%s and copy the code here\n",client_key); - args.stdout("Opening a browser to authorize this app for use with DropBox. Please paste the token here\n"); + args.printf("Opening a browser to authorize this app for use with DropBox. Please paste the token here\n"); int cmd_ret = system(cmd); args.log(LOGARGS, "command returned %d\n", WEXITSTATUS(cmd_ret)); if(WEXITSTATUS(cmd_ret) != 0){ // We don't have a browser. args.log(LOGARGS,"No browser, so we will put the url in the command line.\n"); - args.stdout("oops, you don't seem to have a browser.\n"); - args.stdout("Please go to %s?response_type=code&client_id=%s and log in.\n", OAUTH_2_AUTH, client_key); + args.printf("oops, you don't seem to have a browser.\n"); + args.printf("Please go to %s?response_type=code&client_id=%s and log in.\n", OAUTH_2_AUTH, client_key); } if (fgets(token,128,stdin) == NULL) exit(1); int len = strlen(token); @@ -283,7 +264,7 @@ void do_poll(int interval){ } -void watch_dir(char*path){ +void watch_dir(const char* path){ args.log(LOGARGS,"i am supposed to be monitoring directory %s\n",path); } @@ -302,7 +283,7 @@ int sync_read (int id, char * buffer, int len){ // deprecated return 0; } -int sync_write(char * path, FILE * fp){ +int sync_write(const char * path, FILE * fp){ args.log(LOGARGS,"path = '%s', file = %p\n",path,fp); path += PLUGIN_PREFIX_LEN; json_object * metadata = db_files_put(path,access_token,fp); @@ -311,13 +292,13 @@ int sync_write(char * path, FILE * fp){ return 1; } -int sync_mkdir(char* path){ +int sync_mkdir(const char* path){ path += PLUGIN_PREFIX_LEN; db_mkdir(path,access_token); return 0; } -int sync_rm(char * path){ +int sync_rm(const char * path){ path += PLUGIN_PREFIX_LEN; json_object * response = db_rm(path,access_token); @@ -327,7 +308,7 @@ int sync_rm(char * path){ return 0; } -int sync_mv(char * from, char* to){ +int sync_mv(const char * from, const char* to){ from += PLUGIN_PREFIX_LEN; to += PLUGIN_PREFIX_LEN; db_mv(from,to,access_token); diff --git a/libexec/dropbox.h b/libexec/dropbox.h new file mode 100644 index 0000000..7fdd129 --- /dev/null +++ b/libexec/dropbox.h @@ -0,0 +1,43 @@ +#define _XOPEN_SOURCE 500 +#define XOPEN_SOURCE +#include +#include +#include +#include +#include +#include +#include "../libdropbox/dropbox_api.h" + +#define PLUGIN_PREFIX "dropbox://" +#define PLUGIN_PREFIX_LEN 10 // i counted +#include + +#ifdef WIN32 + #include "strptime.h" + #define EXPORT_SHARED __declspec(dllexport) +#else + #include + #define EXPORT_SHARED +#endif + +#if defined(_WIN32) +#define URL_OPEN_CMD "start \"\"" +#define SILENT_CMD "" +#elif defined(__APPLE__) && defined(__MACH__) +#define URL_OPEN_CMD "open" +#define SILENT_CMD "" +#else +#define URL_OPEN_CMD "sh -c 'xdg-open" +#define SILENT_CMD "' >/dev/null 2&>/dev/null" +#endif + +const char * EXPORT_SHARED init (init_args ); +void EXPORT_SHARED sync_listen (int(*)(const char*,int) ); +FILE * EXPORT_SHARED sync_open_file (const char* ); +int EXPORT_SHARED sync_write (const char*,FILE * ); +int EXPORT_SHARED sync_rm (const char* ); +int EXPORT_SHARED sync_mv (const char*,const char* ); +void EXPORT_SHARED watch_dir (const char* ); +int EXPORT_SHARED sync_mkdir (const char* ); +void EXPORT_SHARED sync_unload ( ); +const char * EXPORT_SHARED get_prefix ( ); \ No newline at end of file diff --git a/libexec/gdrive.c b/libexec/gdrive.c index cd3ea88..6ebc019 100644 --- a/libexec/gdrive.c +++ b/libexec/gdrive.c @@ -18,35 +18,8 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ - -#define _XOPEN_SOURCE 500 -#include -#include -#include "../libgdrive/gdrive_api.h" -#include "../src/os.h" -#include "../src/json_helper.h" - - -#define PLUGIN_PREFIX "gdrive://" -#define PLUGIN_PREFIX_LEN 9 -#include "../src/plugin.h" -#include "gdrive_cache.h" - - -#define __GLOBAL_CLIENT_SECRET "gcyc89d--P9nUb1KagVeV496" -#define __GLOBAL_CLIENT_ID "969830472849-93kt0dqjevn8jgr3g6erissiocdhk2fo.apps.googleusercontent.com" -#define REFRESH_TOKEN "1/8obRmFxvhhebWSCYckmw_AfUlfTD-ERnwvoro8tMAKI" - -#if defined(_WIN32) -#define URL_OPEN_CMD "start \"\"" -#define SILENT_CMD "" -#elif defined(__APPLE__) && defined(__MACH__) -#define URL_OPEN_CMD "open" -#define SILENT_CMD "2&>/dev/null" -#else -#define URL_OPEN_CMD "sh -c 'xdg-open" -#define SILENT_CMD "' 2&>/dev/null" -#endif + +#include "gdrive.h" bool check_error(json_object* obj); char * mkdirP(const char * path); @@ -59,6 +32,13 @@ utilities local_utils; utilities utils; init_args args; +#ifndef HAVE_WARN_H + int WEXITSTATUS(int in){ + args.log(LOGARGS, "COMPAT_WEXITSTATUS in=%d, %x", in,in ); + return in; + } +#endif + json_object * lc_get(){ if (local_cache == NULL){ local_cache = json_object_get(global_utils.getCache(PLUGIN_PREFIX)); @@ -250,15 +230,15 @@ char * login(){ if(WEXITSTATUS(cmd_ret) != 0){ // We don't have a browser. args.log(LOGARGS,"No browser, so we will put the url in the command line.\n"); - args.stdout("oops, you don't seem to have a browser.\n"); - args.stdout("Please go to %s?client_id=%s&redirect_uri=%s&scope=%s&response_type=code and log in.", + args.printf("oops, you don't seem to have a browser.\n"); + args.printf("Please go to %s?client_id=%s&redirect_uri=%s&scope=%s&response_type=code and log in.", "https://accounts.google.com/o/oauth2/auth", __GLOBAL_CLIENT_ID, "urn:ietf:wg:oauth:2.0:oob", "https://www.googleapis.com/auth/drive" ); } - args.stdout("Paste code here\n"); + args.printf("Paste code here\n"); if (fgets(token,128,stdin) == NULL) exit(1); int len = strlen(token); if (token[len-1] == '\n') token[len-1] = '\0'; @@ -552,7 +532,7 @@ void sync_listen( int (*call_back)(const char*path,int type)){ * adds path to be watched for changes the plugin should only report changes * that occur in watched directories. */ -void watch_dir(char * path){ +void watch_dir(const char * path){ } @@ -561,7 +541,7 @@ void watch_dir(char * path){ * this file is not required to be seekable, ie it may be a pipe/stream. */ -FILE * sync_open(char * path){ +FILE * sync_open(const char * path){ path += PLUGIN_PREFIX_LEN; FILE * file; json_object * fcache = get_metadata(NULL,path); @@ -581,7 +561,7 @@ FILE * sync_open(char * path){ * returns the number of bytes written. * NOTE: this function may need to accept MIME type and file size later. */ -int sync_write(char * path, FILE * fp){ +int sync_write(const char * path, FILE * fp){ path += PLUGIN_PREFIX_LEN; int resp = upload(path,fp); return resp; @@ -593,7 +573,7 @@ int sync_write(char * path, FILE * fp){ * this behavior is akin to mkdir -p on *nix * returns non-zero if error */ -int sync_mkdir(char * path){ +int sync_mkdir(const char * path){ return 0; } @@ -601,7 +581,7 @@ int sync_mkdir(char * path){ * remove path whether file or directory. akin to rm -r on linux. * return non-zero if error */ -int sync_rm(char * path){ +int sync_rm(const char * path){ return 0; } @@ -609,6 +589,6 @@ int sync_rm(char * path){ * move file from to new location to. * return non-zero on error */ -int sync_mv(char * path){ +int sync_mv(const char * from, const char * to){ return 0; } diff --git a/libexec/gdrive.h b/libexec/gdrive.h new file mode 100644 index 0000000..bc614a2 --- /dev/null +++ b/libexec/gdrive.h @@ -0,0 +1,45 @@ +#define _XOPEN_SOURCE 500 +#include +#include "../libgdrive/gdrive_api.h" +#include "../src/os.h" +#include "../src/json_helper.h" + +#ifdef WIN32 + #include "strptime.h" + #define SHARED_EXPORT __declspec(dllexport) +#else + #include + #define SHARED_EXPORT +#endif + +#define PLUGIN_PREFIX "gdrive://" +#define PLUGIN_PREFIX_LEN 9 +#include "../src/plugin.h" +#include "gdrive_cache.h" + + +#define __GLOBAL_CLIENT_SECRET "gcyc89d--P9nUb1KagVeV496" +#define __GLOBAL_CLIENT_ID "969830472849-93kt0dqjevn8jgr3g6erissiocdhk2fo.apps.googleusercontent.com" +#define REFRESH_TOKEN "1/8obRmFxvhhebWSCYckmw_AfUlfTD-ERnwvoro8tMAKI" + +#if defined (WIN32) +#define URL_OPEN_CMD "start \"\"" +#define SILENT_CMD "" +#elif defined(__APPLE__) && defined(__MACH__) +#define URL_OPEN_CMD "open" +#define SILENT_CMD "2&>/dev/null" +#else +#define URL_OPEN_CMD "sh -c 'xdg-open" +#define SILENT_CMD "' 2&>/dev/null" +#endif + +const char * EXPORT_SHARED init (init_args ); +void EXPORT_SHARED sync_listen (int(*)(const char*,int) ); +FILE * EXPORT_SHARED sync_open_file (const char* ); +int EXPORT_SHARED sync_write (const char*,FILE * ); +int EXPORT_SHARED sync_rm (const char* ); +int EXPORT_SHARED sync_mv (const char*,const char* ); +void EXPORT_SHARED watch_dir (const char* ); +int EXPORT_SHARED sync_mkdir (const char* ); +void EXPORT_SHARED sync_unload ( ); +const char * EXPORT_SHARED get_prefix ( ); \ No newline at end of file diff --git a/libexec/strptime.c b/libexec/strptime.c new file mode 100644 index 0000000..84f7d52 --- /dev/null +++ b/libexec/strptime.c @@ -0,0 +1,560 @@ + /* Convert a string representation of time to a time value. + Copyright (C) 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Ulrich Drepper , 1996. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with the GNU C Library; see the file COPYING.LIB. If not, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + + void get_locale_strings(void); + + /* XXX This version of the implementation is not really complete. + Some of the fields cannot add information alone. But if seeing + some of them in the same format (such as year, week and weekday) + this is enough information for determining the date. */ + + #include + #include + #include + #include + + #define match_char(ch1, ch2) if (ch1 != ch2) return NULL + + #ifndef Macintosh + #if defined __GNUC__ && __GNUC__ >= 2 + # define match_string(cs1, s2) \ + ({ size_t len = strlen (cs1); \ + int result = strncasecmp ((cs1), (s2), len) == 0; \ + if (result) (s2) += len; \ + result; }) + #else + /* Oh come on. Get a reasonable compiler. */ + # define match_string(cs1, s2) \ + (strncasecmp ((cs1), (s2), strlen (cs1)) ? 0 : ((s2) += strlen (cs1), 1)) + #endif + #else + # define match_string(cs1, s2) \ + (strncmp ((cs1), (s2), strlen (cs1)) ? 0 : ((s2) += strlen (cs1), 1)) + #endif /* mac */ + + /* We intentionally do not use isdigit() for testing because this will + lead to problems with the wide character version. */ + #define get_number(from, to, n) \ + do { \ + int __n = n; \ + val = 0; \ + while (*rp == ' ') \ + ++rp; \ + if (*rp < '0' || *rp > '9') \ + return NULL; \ + do { \ + val *= 10; \ + val += *rp++ - '0'; \ + } while (--__n > 0 && val * 10 <= to && *rp >= '0' && *rp <= '9'); \ + if (val < from || val > to) \ + return NULL; \ + } while (0) + # define get_alt_number(from, to, n) \ + /* We don't have the alternate representation. */ \ + get_number(from, to, n) + #define recursive(new_fmt) \ + (*(new_fmt) != '\0' \ + && (rp = strptime_internal (rp, (new_fmt), tm, decided)) != NULL) + + /* This version: may overwrite these with versions for the locale */ + static char weekday_name[][20] = + { + "Sunday", "Monday", "Tuesday", "Wednesday", + "Thursday", "Friday", "Saturday" + }; + static char ab_weekday_name[][10] = + { + "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" + }; + static char month_name[][20] = + { + "January", "February", "March", "April", "May", "June", + "July", "August", "September", "October", "November", "December" + }; + static char ab_month_name[][10] = + { + "Jan", "Feb", "Mar", "Apr", "May", "Jun", + "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" + }; + + static char am_pm[][4] = {"AM", "PM"}; + + + # define HERE_D_T_FMT "%a %b %e %H:%M:%S %Y" + # define HERE_D_FMT "%y/%m/%d" + # define HERE_T_FMT_AMPM "%I:%M:%S %p" + # define HERE_T_FMT "%H:%M:%S" + + static const unsigned short int __mon_yday[2][13] = + { + /* Normal years. */ + { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 }, + /* Leap years. */ + { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 } + }; + + + /* Status of lookup: do we use the locale data or the raw data? */ + enum locale_status { not, loc, raw }; + + # define __isleap(year) \ + ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0)) + + /* Compute the day of the week. */ + void + day_of_the_week (struct tm *tm) + { + /* We know that January 1st 1970 was a Thursday (= 4). Compute the + the difference between this data in the one on TM and so determine + the weekday. */ + int corr_year = 1900 + tm->tm_year - (tm->tm_mon < 2); + int wday = (-473 + + (365 * (tm->tm_year - 70)) + + (corr_year / 4) + - ((corr_year / 4) / 25) + ((corr_year / 4) % 25 < 0) + + (((corr_year / 4) / 25) / 4) + + __mon_yday[0][tm->tm_mon] + + tm->tm_mday - 1); + tm->tm_wday = ((wday % 7) + 7) % 7; + } + + /* Compute the day of the year. */ + void + day_of_the_year (struct tm *tm) + { + tm->tm_yday = (__mon_yday[__isleap (1900 + tm->tm_year)][tm->tm_mon] + + (tm->tm_mday - 1)); + } + + char * + strptime_internal (const char *rp, const char *fmt, struct tm *tm, + enum locale_status *decided) + { + const char *rp_backup; + int cnt; + size_t val; + int have_I, is_pm; + int century, want_century; + int have_wday, want_xday; + int have_yday; + int have_mon, have_mday; + + have_I = is_pm = 0; + century = -1; + want_century = 0; + have_wday = want_xday = have_yday = have_mon = have_mday = 0; + + while (*fmt != '\0') + { + /* A white space in the format string matches 0 more or white + space in the input string. */ + if (isspace (*fmt)) + { + while (isspace (*rp)) + ++rp; + ++fmt; + continue; + } + + /* Any character but `%' must be matched by the same character + in the iput string. */ + if (*fmt != '%') + { + match_char (*fmt++, *rp++); + continue; + } + + ++fmt; + + /* We need this for handling the `E' modifier. */ + start_over: + + /* Make back up of current processing pointer. */ + rp_backup = rp; + + switch (*fmt++) + { + case '%': + /* Match the `%' character itself. */ + match_char ('%', *rp++); + break; + case 'a': + case 'A': + /* Match day of week. */ + for (cnt = 0; cnt < 7; ++cnt) + { + if (*decided != loc + && (match_string (weekday_name[cnt], rp) + || match_string (ab_weekday_name[cnt], rp))) + { + *decided = raw; + break; + } + } + if (cnt == 7) + /* Does not match a weekday name. */ + return NULL; + tm->tm_wday = cnt; + have_wday = 1; + break; + case 'b': + case 'B': + case 'h': + /* Match month name. */ + for (cnt = 0; cnt < 12; ++cnt) + { + if (match_string (month_name[cnt], rp) + || match_string (ab_month_name[cnt], rp)) + { + *decided = raw; + break; + } + } + if (cnt == 12) + /* Does not match a month name. */ + return NULL; + tm->tm_mon = cnt; + want_xday = 1; + break; + case 'c': + /* Match locale's date and time format. */ + if (!recursive (HERE_T_FMT_AMPM)) + return NULL; + break; + case 'C': + /* Match century number. */ + get_number (0, 99, 2); + century = val; + want_xday = 1; + break; + case 'd': + case 'e': + /* Match day of month. */ + get_number (1, 31, 2); + tm->tm_mday = val; + have_mday = 1; + want_xday = 1; + break; + case 'F': + if (!recursive ("%Y-%m-%d")) + return NULL; + want_xday = 1; + break; + case 'x': + /* Fall through. */ + case 'D': + /* Match standard day format. */ + if (!recursive (HERE_D_FMT)) + return NULL; + want_xday = 1; + break; + case 'k': + case 'H': + /* Match hour in 24-hour clock. */ + get_number (0, 23, 2); + tm->tm_hour = val; + have_I = 0; + break; + case 'I': + /* Match hour in 12-hour clock. */ + get_number (1, 12, 2); + tm->tm_hour = val % 12; + have_I = 1; + break; + case 'j': + /* Match day number of year. */ + get_number (1, 366, 3); + tm->tm_yday = val - 1; + have_yday = 1; + break; + case 'm': + /* Match number of month. */ + get_number (1, 12, 2); + tm->tm_mon = val - 1; + have_mon = 1; + want_xday = 1; + break; + case 'M': + /* Match minute. */ + get_number (0, 59, 2); + tm->tm_min = val; + break; + case 'n': + case 't': + /* Match any white space. */ + while (isspace (*rp)) + ++rp; + break; + case 'p': + /* Match locale's equivalent of AM/PM. */ + if (!match_string (am_pm[0], rp)) + if (match_string (am_pm[1], rp)) + is_pm = 1; + else + return NULL; + break; + case 'r': + if (!recursive (HERE_T_FMT_AMPM)) + return NULL; + break; + case 'R': + if (!recursive ("%H:%M")) + return NULL; + break; + case 's': + { + /* The number of seconds may be very high so we cannot use + the `get_number' macro. Instead read the number + character for character and construct the result while + doing this. */ + time_t secs = 0; + if (*rp < '0' || *rp > '9') + /* We need at least one digit. */ + return NULL; + + do + { + secs *= 10; + secs += *rp++ - '0'; + } + while (*rp >= '0' && *rp <= '9'); + + if ((tm = localtime (&secs)) == NULL) + /* Error in function. */ + return NULL; + } + break; + case 'S': + get_number (0, 61, 2); + tm->tm_sec = val; + break; + case 'X': + /* Fall through. */ + case 'T': + if (!recursive (HERE_T_FMT)) + return NULL; + break; + case 'u': + get_number (1, 7, 1); + tm->tm_wday = val % 7; + have_wday = 1; + break; + case 'g': + get_number (0, 99, 2); + /* XXX This cannot determine any field in TM. */ + break; + case 'G': + if (*rp < '0' || *rp > '9') + return NULL; + /* XXX Ignore the number since we would need some more + information to compute a real date. */ + do + ++rp; + while (*rp >= '0' && *rp <= '9'); + break; + case 'U': + case 'V': + case 'W': + get_number (0, 53, 2); + /* XXX This cannot determine any field in TM without some + information. */ + break; + case 'w': + /* Match number of weekday. */ + get_number (0, 6, 1); + tm->tm_wday = val; + have_wday = 1; + break; + case 'y': + /* Match year within century. */ + get_number (0, 99, 2); + /* The "Year 2000: The Millennium Rollover" paper suggests that + values in the range 69-99 refer to the twentieth century. */ + tm->tm_year = val >= 69 ? val : val + 100; + /* Indicate that we want to use the century, if specified. */ + want_century = 1; + want_xday = 1; + break; + case 'Y': + /* Match year including century number. */ + get_number (0, 9999, 4); + tm->tm_year = val - 1900; + want_century = 0; + want_xday = 1; + break; + case 'Z': + /* XXX How to handle this? */ + break; + case 'E': + /* We have no information about the era format. Just use + the normal format. */ + if (*fmt != 'c' && *fmt != 'C' && *fmt != 'y' && *fmt != 'Y' + && *fmt != 'x' && *fmt != 'X') + /* This is an invalid format. */ + return NULL; + + goto start_over; + case 'O': + switch (*fmt++) + { + case 'd': + case 'e': + /* Match day of month using alternate numeric symbols. */ + get_alt_number (1, 31, 2); + tm->tm_mday = val; + have_mday = 1; + want_xday = 1; + break; + case 'H': + /* Match hour in 24-hour clock using alternate numeric + symbols. */ + get_alt_number (0, 23, 2); + tm->tm_hour = val; + have_I = 0; + break; + case 'I': + /* Match hour in 12-hour clock using alternate numeric + symbols. */ + get_alt_number (1, 12, 2); + tm->tm_hour = val - 1; + have_I = 1; + break; + case 'm': + /* Match month using alternate numeric symbols. */ + get_alt_number (1, 12, 2); + tm->tm_mon = val - 1; + have_mon = 1; + want_xday = 1; + break; + case 'M': + /* Match minutes using alternate numeric symbols. */ + get_alt_number (0, 59, 2); + tm->tm_min = val; + break; + case 'S': + /* Match seconds using alternate numeric symbols. */ + get_alt_number (0, 61, 2); + tm->tm_sec = val; + break; + case 'U': + case 'V': + case 'W': + get_alt_number (0, 53, 2); + /* XXX This cannot determine any field in TM without + further information. */ + break; + case 'w': + /* Match number of weekday using alternate numeric symbols. */ + get_alt_number (0, 6, 1); + tm->tm_wday = val; + have_wday = 1; + break; + case 'y': + /* Match year within century using alternate numeric symbols. */ + get_alt_number (0, 99, 2); + tm->tm_year = val >= 69 ? val : val + 100; + want_xday = 1; + break; + default: + return NULL; + } + break; + default: + return NULL; + } + } + + if (have_I && is_pm) + tm->tm_hour += 12; + + if (century != -1) + { + if (want_century) + tm->tm_year = tm->tm_year % 100 + (century - 19) * 100; + else + /* Only the century, but not the year. Strange, but so be it. */ + tm->tm_year = (century - 19) * 100; + } + + if (want_xday && !have_wday) { + if ( !(have_mon && have_mday) && have_yday) { + /* we don't have tm_mon and/or tm_mday, compute them */ + int t_mon = 0; + while (__mon_yday[__isleap(1900 + tm->tm_year)][t_mon] <= tm->tm_yday) + t_mon++; + if (!have_mon) + tm->tm_mon = t_mon - 1; + if (!have_mday) + tm->tm_mday = tm->tm_yday - __mon_yday[__isleap(1900 + tm->tm_year)][t_mon - 1] + 1; + } + day_of_the_week (tm); + } + if (want_xday && !have_yday) + day_of_the_year (tm); + + return (char *) rp; + } + + char * + strptime (const char *buf, const char *format, struct tm *tm) + { + enum locale_status decided; + #ifdef HAVE_LOCALE_H + if(!have_used_strptime) { + get_locale_strings(); + /* have_used_strptime = 1; might change locale during session */ + } + #endif + decided = raw; + return strptime_internal (buf, format, tm, &decided); + } + + #ifdef HAVE_LOCALE_H + void get_locale_strings(void) + { + int i; + struct tm tm; + char buff[4]; + + tm.tm_sec = tm.tm_min = tm.tm_hour = tm.tm_mday = tm.tm_mon + = tm.tm_isdst = 0; + tm.tm_year = 30; + for(i = 0; i < 12; i++) { + tm.tm_mon = i; + strftime(ab_month_name[i], 10, "%b", &tm); + strftime(month_name[i], 20, "%B", &tm); + } + tm.tm_mon = 0; + for(i = 0; i < 7; i++) { + tm.tm_mday = tm.tm_yday = i+1; /* 2000-1-2 was a Sunday */ + tm.tm_wday = i; + strftime(ab_weekday_name[i], 10, "%a", &tm); + strftime(weekday_name[i], 20, "%A", &tm); + } + tm.tm_hour = 1; + /* in locales where these are unused, they may be empty: better + not to reset them then */ + strftime(buff, 4, "%p", &tm); + if(strlen(buff)) strcpy(am_pm[0], buff); + tm.tm_hour = 13; + strftime(buff, 4, "%p", &tm); + if(strlen(buff)) strcpy(am_pm[1], buff); + } + #endif diff --git a/libexec/strptime.h b/libexec/strptime.h new file mode 100644 index 0000000..c50e9ed --- /dev/null +++ b/libexec/strptime.h @@ -0,0 +1,7 @@ +#ifndef __STRPTIME_H_ +#define __STRPTIME_H_ + +char* strptime (const char *buf, const char *format, struct tm *tm); + +#endif + diff --git a/libexec/syncfs.c b/libexec/syncfs.c index 9c1b9d7..ae7d1f8 100644 --- a/libexec/syncfs.c +++ b/libexec/syncfs.c @@ -19,43 +19,7 @@ * THE SOFTWARE. */ -#define _XOPEN_SOURCE 500 -#include -#include -#include -#include -#include -#include -#include -/* "readdir" etc. are defined here. */ -#include -/* limits.h defines "PATH_MAX". */ -#include -#include -#define PLUGIN_PREFIX "file://" -#define PLUGIN_PREFIX_LEN 7 -#include - -#define HAVE_INOTIFY_H - -char* init(init_args); -void add_watch(char *); -void watch_dir(char *); -void sync_listen(int(*)(const char*,int)); -int sync_mkdir(char*); -int update_file_cache(char*,int); -int(*update_event)(const char*,int); -init_args args; - -//#ifdef HAVE_CONFIG_H -//# include -#ifdef HAVE_INOTIFY_H -# include "linuxfs.c" -# else -# include "uvfs.c" -# endif -//#endif - +#include "syncfs.h" FILE ** open_files; int num_open_files; @@ -226,7 +190,13 @@ int mkpath(char* file_path, mode_t mode) { char* p; for (p=strchr(file_path+1, '/'); p; p=strchr(p+1, '/')) { *p='\0'; - if (mkdir(file_path, mode)==-1) { + + if (mkdir( + file_path +#ifndef WIN32 + ,mode +#endif + )==-1) { if (errno!=EEXIST) { *p='/'; return -1; } } *p='/'; diff --git a/libexec/syncfs.h b/libexec/syncfs.h new file mode 100644 index 0000000..77d3fa0 --- /dev/null +++ b/libexec/syncfs.h @@ -0,0 +1,41 @@ +#ifndef _SYNCFS_H_ +#define _SYNCFS_H_ + +#define _XOPEN_SOURCE 500 +#include +#include +#include +#include +#include +#include +#undef PLUGIN_PREFIX +#include +/* "readdir" etc. are defined here. */ +#include +/* limits.h defines "PATH_MAX". */ +#include +#define PLUGIN_PREFIX "file://" +#define PLUGIN_PREFIX_LEN 7 + +#if defined _MSC_VER +#include +#elif defined __GNUC__ +#include +#include +#endif + +// Variables +int(*update_event)(const char*,int); +init_args args; + + +//Prototypes +void add_watch(char *); +void watch_dir(char *); +void sync_listen(int(*)(const char*,int)); +int sync_mkdir(char*); +int update_file_cache(char*,int); +void local_init(); +void local_unload(); + +#endif diff --git a/libexec/uvfs.c b/libexec/uvfs.c index b620b68..bf09945 100644 --- a/libexec/uvfs.c +++ b/libexec/uvfs.c @@ -19,6 +19,7 @@ * THE SOFTWARE. */ +#include "syncfs.h" #include uv_loop_t *loop; @@ -46,9 +47,10 @@ void uvfs_updates(uv_fs_event_t *handle, const char *filename, int events, int s void add_watch(char * dir_name){ uv_fs_event_t *fs_event_req = malloc(sizeof(uv_fs_event_t)); fs_event_req->data = strdup(dir_name); - //uv_fs_event_init(loop, fs_event_req); + uv_fs_event_init(loop, fs_event_req); + uv_fs_event_start(fs_event_req, uvfs_updates, dir_name, UV_FS_EVENT_RECURSIVE); // The recursive flag watches subdirectories too. - uv_fs_event_init(loop,fs_event_req, dir_name,uvfs_updates, UV_FS_EVENT_RECURSIVE); + //uv_fs_event_init(loop,fs_event_req, dir_name,uvfs_updates, UV_FS_EVENT_RECURSIVE); } diff --git a/libgdrive/CMakeLists.txt b/libgdrive/CMakeLists.txt index a3ffe83..7661463 100644 --- a/libgdrive/CMakeLists.txt +++ b/libgdrive/CMakeLists.txt @@ -1,3 +1,5 @@ +include_directories("${CMAKE_ROOT}") + add_library(gdrive gdrive_api.c) set_property(TARGET gdrive PROPERTY POSITION_INDEPENDENT_CODE ON) -target_link_libraries(gdrive LINK_PRIVATE rest json-c) +target_link_libraries(gdrive LINK_PRIVATE rest ${JSONC_LIBRARIES}) diff --git a/libgdrive/gdrive_api.c b/libgdrive/gdrive_api.c index a6172f8..6120ab3 100644 --- a/libgdrive/gdrive_api.c +++ b/libgdrive/gdrive_api.c @@ -35,7 +35,7 @@ bool JSON_GET_BOOL(json_object * obj, const char * object, bool def){ return def; } -char * _safe_strdup(const char * in){ +char * gdrive_safe_strdup(const char * in){ if (in == NULL) return NULL; return strdup(in); } @@ -78,7 +78,7 @@ json_object * gdrive_get_metadata(const char * file_id){ FILE * gdrive_get (const char * file_id){ json_object * metadata = gdrive_get_metadata(file_id); - char * download_url = _safe_strdup(JSON_GET_STRING(metadata,"downloadUrl")); + char * download_url = gdrive_safe_strdup(JSON_GET_STRING(metadata,"downloadUrl")); if (download_url == NULL) return NULL; download_url = (char*)realloc(download_url, strlen(download_url) diff --git a/librest/CMakeLists.txt b/librest/CMakeLists.txt index f3bc7d7..316c4ed 100644 --- a/librest/CMakeLists.txt +++ b/librest/CMakeLists.txt @@ -1,3 +1,5 @@ +find_package(CURL) + +include_directories(${CURL_INCLUDE_DIRS}) add_library(rest rest.c buffer.c) -set_property(TARGET rest PROPERTY POSITION_INDEPENDENT_CODE ON) -target_link_libraries(rest LINK_PUBLIC curl) +target_link_libraries(rest LINK_PUBLIC ${CURL_LIBRARIES}) diff --git a/librest/Makefile.old b/librest/Makefile.old index 1fafeb5..04c40aa 100644 --- a/librest/Makefile.old +++ b/librest/Makefile.old @@ -1,13 +1,4 @@ -CCFLAGS := -ggdb -fno-stack-protector - -ifeq ($(libdir),) -ifeq ($(shell uname -m),x86_64) -libdir:=/usr/local/lib64 -else -libdir:=/usr/local/lib -endif -endif - +CCFLAGS := -ggdb ifeq ($(CC),cc) SL :=.so CCFLAGS := $(CCFLAGS) -fPIC @@ -20,17 +11,16 @@ EXE:=.exe LIBS:= $(shell $(PKG_CONFIG) --static --libs libcurl ) OBJ:=.wo endif - all : librest$(SL) - -install : $(libdir)/librest$(SL) - -$(libdir)/librest$(SL) : librest$(SL) - libtool --mode=install install $(notdir $<) $(libdir)/$(notdir $<) +#dropbox.exe: dropbox_api.o dropbox_main.o +# $(CC) -o dropbox.exe dropbox_api.o dropbox_main.o -lpthread -static -ljson-c -Lcurl/lib -lrtmp $(LIBS) -liconv -lrtmp -lssl -lwinmm -lws2_32 librest.so: rest.o buffer.o $(LD) -shared -o librest.so rest.o buffer.o +#librest.dll: rest.o buffer.o +# $(LD) --no-undefined --enable-runtime-pseudo-reloc -shared -o librest.dll rest.o buffer.o -static -ljson-c -lpthread -Lcurl/lib -lrtmp $(LIBS) -liconv -lrtmp -lssl -lwinmm -lws2_32 --out-implib librestdll.a + librest.dll: rest.wo buffer.wo $(CC) -shared -o librest.dll rest.wo buffer.wo -Wl,--out-implib,librestdll.a -static curl/lib/libcurl.a curl/lib/libssl.a curl/lib/libidn.a curl/lib/libcrypto.a curl/lib/librtmp.a curl/lib/libssh2.a curl/lib/libssl.a curl/lib/libz.a -lpthread -lws2_32 -lwinmm -lgdi32 -lwldap32 -Wl,--out-implib,librestdll.a,--no-undefined,--enable-runtime-pseudo-reloc diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index c7283b4..e72caf7 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -1,4 +1,13 @@ +find_package(LTDL) include_directories("${CMAKE_CURRENT_LIST_DIR}") -add_executable(syncd syncd.c cache.c ipc_semaphore.c shared_memory.c json_helper.c log.c os.h plugin.h) -target_link_libraries(syncd LINK_PUBLIC json-c ltdl rt pthread) +include_directories("${LTDL_INCLUDE_DIRS}") +IF(WIN32) + find_package(mman) +ENDIF() + +add_executable(syncd syncd.c cache.c ipc_semaphore.c shared_memory.c json_helper.c log.c) +target_link_libraries(syncd LINK_PRIVATE ${CMAKE_THREAD_LIBS_INIT} ${LTDL_LIBRARIES} ${JSONC_LIBRARIES} ${MMAN_LIBRARIES}) + +add_executable(testPlugin testPlugin.c cache.c ipc_semaphore.c shared_memory.c json_helper.c log.c) +target_link_libraries(testPlugin LINK_PRIVATE ${CMAKE_THREAD_LIBS_INIT} ${LTDL_LIBRARIES} ${JSONC_LIBRARIES} ${MMAN_LIBRARIES}) diff --git a/src/cache.c b/src/cache.c index 818e540..c4ee5b6 100644 --- a/src/cache.c +++ b/src/cache.c @@ -26,16 +26,24 @@ #include #include #include -#include #include #include #include "ipc_semaphore.h" #include "log.h" +#include #ifndef MAP_FILE #define MAP_FILE 0 #endif +#ifndef HAVE_ERR_H +void errx(int i,const char * in){ + return; +} +#else +#include +#endif + json_object * cache; json_object * config; diff --git a/src/cache.h b/src/cache.h index 93474ab..7562af8 100644 --- a/src/cache.h +++ b/src/cache.h @@ -23,7 +23,6 @@ #define __CACHE_H_ #include - /* Definition of functions provided by sync */ diff --git a/src/log.c b/src/log.c index cf50283..8a63cc6 100644 --- a/src/log.c +++ b/src/log.c @@ -1,21 +1,25 @@ #include "log.h" -#include -#define _GNU_SOURCE -#include #include #include FILE *__logfile; -int __stderr; -int __stdout; +FILE *__stderr; +FILE *__stdout; + +int __stderr_fd; +int __stdout_fd; + void logging_init(const char *filename) { // backup stdout and stderr - __stderr = dup(fileno(stderr)); - __stdout = dup(fileno(stdout)); + __stderr_fd = dup(fileno(stderr)); + __stdout_fd = dup(fileno(stdout)); + + __stdout = fdopen(__stdout_fd, "a"); + __stderr = fdopen(__stderr_fd, "a"); // open the logfile under the filedescriptor of stdout __logfile = freopen(filename, "a", stdout); @@ -38,7 +42,8 @@ void logging_stdout(const char * fmt, ...) { va_list args; va_start(args, fmt); - vdprintf (__stdout, fmt, args); + //vdprintf (__stdout_fd, fmt, args); + vfprintf (__stdout, fmt, args); va_end(args); } @@ -46,16 +51,17 @@ void logging_stderr(const char * fmt, ...) { va_list args; va_start(args, fmt); - vdprintf (__stdout, fmt, args); + //vdprintf (__stdout_fd, fmt, args); + vfprintf (__stdout, fmt, args); va_end(args); } void logging_close() { - dup2(__stdout, fileno(stdout)); - dup2(__stderr, fileno(stderr)); + dup2(__stdout_fd, fileno(stdout)); + dup2(__stderr_fd, fileno(stderr)); - close(__stderr); - close(__stdout); + close(__stderr_fd); + close(__stdout_fd); } diff --git a/src/os.h b/src/os.h index f8e14c2..edf1cf4 100644 --- a/src/os.h +++ b/src/os.h @@ -28,17 +28,8 @@ #include #include #include "cache.h" -//#include -#define HAVE_FORK -#ifndef HAVE_FORK - #define fork() pseudo_fork(i,argv[0]) - int pseudo_fork(int plugin_num,char * exec_name){ - char pnum[5]; - sprintf(&pnum,"%d",plugin_num) - printf("running '%s %s %s'\n",exec_name,"-p",pnum); - int error = spawnl(P_NOWAIT,exec_name,exec_name,"-p",pnum); - } -#endif +#include + #if defined(WIN32) #include #include diff --git a/src/plugin.c b/src/plugin.c index ea46730..101d662 100644 --- a/src/plugin.c +++ b/src/plugin.c @@ -1,10 +1,29 @@ -#include +//#include #include "plugin.h" #include #include #include "os.h" +bool __sigterm__ = false; +void set_sigterm(int signum){ + __sigterm__ = true; +} + +bool plugin_get_sigterm(){ + return __sigterm__; +} + +void plugin_catch_events(){ +#ifndef WIN32 + struct sigaction action; + memset(&action, 0, sizeof(struct sigaction)); + action.sa_handler = set_sigterm; + sigaction(SIGTERM, &action, NULL); +#endif +} + + /* plugin * get_plugin(char * filename, init_args args){ lt_dlhandle ptr = lt_dlopen(filename); @@ -65,3 +84,4 @@ int loadPlugins(plugin *** return_plugins, char * dir_name){ } +*/ \ No newline at end of file diff --git a/src/plugin.h b/src/plugin.h index ec5de18..9e59a4d 100644 --- a/src/plugin.h +++ b/src/plugin.h @@ -26,7 +26,7 @@ #include "cache.h" #include "log.h" #include -#include +//#include #include #define S_CLOSE_WRITE 0x00000008 @@ -44,8 +44,8 @@ typedef struct { utilities utils; int(*event_callback)(const char*,int); LOGGING_LOG log; - LOGGING_STDOUT stdout; - LOGGING_STDERR stderr; + LOGGING_STDOUT printf; + LOGGING_STDERR error; //JSON json; } init_args; @@ -61,39 +61,10 @@ typedef int (*S_MKDIR ) (const char* ); typedef void (*S_UNLOAD ) ( ); -typedef struct{ - /* functions */ - S_INIT init; - S_LISTEN listen; - S_WATCH_DIR watch_dir; - S_OPEN_FILE open; - S_WRITE write; - S_RM rm; - S_MV mv; - S_MKDIR mkdir; - S_UNLOAD unload; - /* properties */ - char * prefix; - int prefix_len; - lt_dlhandle dlhandle; -} plugin; +bool plugin_get_sigterm(); +void plugin_catch_events(); +#define CATCH_EVENTS plugin_catch_events(); +#define CLEAN_BREAK if (plugin_get_sigterm()) return; -//int loadPlugins(plugin ***plugins, -// char *dir); -#ifdef PLUGIN_PREFIX - bool __sigterm__ = false; - #define CATCH_EVENTS __catch_events(); - void __set_sigterm(int signum){ - __sigterm__ = true; - } - void __catch_events(){ - struct sigaction action; - memset(&action, 0, sizeof(struct sigaction)); - action.sa_handler = __set_sigterm; - sigaction(SIGTERM, &action, NULL); - } - #define CLEAN_BREAK if (__sigterm__) return; -#endif - -#endif +#endif \ No newline at end of file diff --git a/src/plugins.h b/src/plugins.h new file mode 100644 index 0000000..face6e4 --- /dev/null +++ b/src/plugins.h @@ -0,0 +1,16 @@ +typedef struct{ + /* functions */ + S_INIT init; + S_LISTEN listen; + S_WATCH_DIR watch_dir; + S_OPEN_FILE open; + S_WRITE write; + S_RM rm; + S_MV mv; + S_MKDIR mkdir; + S_UNLOAD unload; + /* properties */ + char * prefix; + int prefix_len; + lt_dlhandle dlhandle; +} plugin; \ No newline at end of file diff --git a/src/syncd.c b/src/syncd.c index 7a8e6b7..9ea6acb 100644 --- a/src/syncd.c +++ b/src/syncd.c @@ -28,10 +28,6 @@ #include #include "log.h" -#ifndef LIBDIR -#define LIBDIR "/usr/local/lib/syncd" -#endif - typedef struct { lt_dlhandle ptr; const char * prefix; @@ -42,6 +38,40 @@ int num_plugins; json_object * rules; +#ifndef LIBDIR +#define LIBDIR "plugins" +#endif + +#ifndef HAVE_FORK +#include + #define fork() pseudo_fork(i,argv[0]) + int pseudo_fork(int plugin_num, char * exec_name){ + char pArg[5]; + STARTUPINFO si; + PROCESS_INFORMATION pi; + + memset( &si, 0, sizeof(si) ); + si.cb = sizeof(si); + memset( &pi, 0, sizeof(pi) ); + + sprintf(pArg,"-p %d",plugin_num); + printf("running '%s %s'\n",exec_name,pArg); + //int error = spawnl(P_NOWAIT,exec_name,exec_name,"-p",pnum); + bool success = CreateProcess( exec_name, + pArg, // Command line + NULL, // Process handle not inheritable + NULL, // Thread handle not inheritable + FALSE, // Set handle inheritance to FALSE + 0, // No creation flags + NULL, // Use parent's environment block + NULL, // Use parent's starting directory + &si, // Pointer to STARTUPINFO structure + &pi // Pointer to PROCESS_INFORMATION structure + ); + logging_stdout ("Spawning process with PID %d\n", pi.dwProcessId); + return pi.dwProcessId; + } +#endif json_object * getCacheDetails(int pnum, const char * path) { const char * plugin_prefix = plugins[pnum].prefix; @@ -179,8 +209,8 @@ int cb(const char * path, int mask){ } lt_dlhandle loadPlugin(const char * filename ){ - const char * ext = rindex(filename, '.'); - if(strcmp(ext, ".so") != 0) return NULL; + const char * ext = strrchr(filename, '.'); + if(strcmp(ext, ".la") != 0) return NULL; lt_dlhandle out = lt_dlopen(filename); const char * (*get_prefix)() = (const char * (*)()) lt_dlsym (out, "get_prefix"); if ( get_prefix != NULL){ @@ -213,8 +243,8 @@ int loadPlugins(Plugin **return_plugins){ args.utils = get_utility_functions(); args.event_callback = cb; args.log = logging_log; - args.stdout = logging_stdout; - args.stderr = logging_stderr; + args.printf = logging_stdout; + args.error = logging_stderr; int num_plugins = 0, i=0; DIR * dp; struct dirent *ep; @@ -272,17 +302,25 @@ void add_watch(char* path){ } } +int c_mkdir (const char * path, int mode){ +#ifdef WIN32 + return mkdir(path); +#else + return mkdir(path, mode); +#endif +} + void setupConfig(){ // Create the directories if needed. char path [PATH_MAX]; strcpy(path, getenv("HOME")); strcat(path, "/.config/syncd"); - mkdir(path,0700); + c_mkdir(path,0700); strcat(path,"/log.txt"); logging_init(path); strcpy(path, getenv("HOME")); strcat(path, "/.cache/syncd"); - mkdir(path,0700); + c_mkdir(path,0700); strcpy(path, getenv("HOME")); strcat(path, "/.config/syncd/rules.json"); rules = json_object_from_file(path); diff --git a/src/test b/src/test new file mode 100644 index 0000000000000000000000000000000000000000..c54f2225c15440da264e90b41018123925de68a6 GIT binary patch literal 162601 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 literal 0 HcmV?d00001 diff --git a/src/testPlugin.c b/src/testPlugin.c new file mode 100644 index 0000000..25a73a7 --- /dev/null +++ b/src/testPlugin.c @@ -0,0 +1,48 @@ +#include +#include +#include "plugin.h" +#include "cache.h" + +int cb(const char * name, int mode){ + printf("%s %d\n", name, mode); +} + +int main(int argc, char ** argv){ + if (argc < 2) return 1; + S_INIT init; + S_UNLOAD unload; + char * plugin_name = argv[1]; + char * prefix; + logging_init("plugin_log.txt"); + cache_init(); + lt_dlinit(); + + lt_dlhandle plugin = lt_dlopen(plugin_name); + if (plugin == NULL){ + logging_stdout("Error loading '%s': %s\n", plugin_name, lt_dlerror()); + return 1; + } + + init = (S_INIT ) lt_dlsym(plugin, "init"); + if (init == NULL){ + logging_stdout("Error loading function 'init': %s\n", lt_dlerror()); + return 1; + } + + unload = (S_UNLOAD) lt_dlsym(plugin, "sync_unload"); + if (unload == NULL){ + logging_stdout("Error loading function 'sync_unload': %s\n", lt_dlerror()); + return 1; + } + + init_args args; + args.event_callback = cb; + args.log = logging_log; + args.printf = logging_stdout; + args.error = logging_stderr; + args.utils = get_utility_functions(); + prefix = init(args); + logging_close(); + cache_clear(); + puts(prefix); +} From cbbe0b5263c0a5f6f8088ed74351b028a1994c28 Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Wed, 27 May 2015 02:09:04 -0400 Subject: [PATCH 04/49] last windows fixes to build --- src/cache.c | 8 ++-- src/ipc_semaphore.c | 19 +++++---- src/ipc_semaphore.h | 6 +-- src/shared_memory.c | 95 +++++++++++++++++++++++++++++++++++++-------- src/shared_memory.h | 6 +-- 5 files changed, 97 insertions(+), 37 deletions(-) diff --git a/src/cache.c b/src/cache.c index c4ee5b6..de37d4e 100644 --- a/src/cache.c +++ b/src/cache.c @@ -74,15 +74,15 @@ void cache_init(){ PROT_READ | PROT_WRITE, MAP_FILE|MAP_SHARED, cacheFD, 0); if (cacheFile == MAP_FAILED ) errx(1,"failed"); // setup semaphores. - cache_semaphore = semaphore_create(1); - config_semaphore = semaphore_create(1); + cache_semaphore = semaphore_create(1, "SYNCD\\cache"); + config_semaphore = semaphore_create(1, "SYNCD\\config"); } void cache_clear(){ munmap(cacheFile, cacheLength); close(cacheFD); - semaphore_delete(cache_semaphore); - semaphore_delete(config_semaphore); + semaphore_delete(cache_semaphore, "SYNCD\\cache"); + semaphore_delete(config_semaphore, "SYNCD\\cache"); } json_object * getCache(const char * plugin_prefix){ diff --git a/src/ipc_semaphore.c b/src/ipc_semaphore.c index 0dabf33..7222acc 100644 --- a/src/ipc_semaphore.c +++ b/src/ipc_semaphore.c @@ -1,12 +1,11 @@ #include "ipc_semaphore.h" #include "shared_memory.h" -#ifdef _WINDOWS_ +#ifdef WIN32 - semaphore semaphore_create(unsigned int max){ + semaphore semaphore_create(unsigned int max, const char * name){ semaphore s; - s.semaphore = (HANDLE) shared_mem_alloc(sizeof(HANDLE)); - s.semaphore = CreateSemaphore(NULL,max, max, NULL); + s.semaphore = CreateSemaphore(NULL, max, max, name); s.max = max; return s; } @@ -19,23 +18,23 @@ return ReleaseSemaphore(s.semaphore, 1, NULL); } - void semaphore_destroy(semaphore s){ + int semaphore_delete(semaphore s, const char * name){ CloseHandle(s.semaphore); - shared_mem_dealloc(s.semaphore, sizeof(HANDLE)); + return 1; } #else - semaphore semaphore_create(unsigned int max){ + semaphore semaphore_create(unsigned int max, const char * name){ semaphore s; s.max = max; - s.semaphore = shared_mem_alloc(sizeof(sem_t)); + s.semaphore = shared_mem_alloc(sizeof(sem_t), name); sem_init(s.semaphore, 1,max); return s; } - int semaphore_delete(semaphore s){ - int ret = sem_destroy(s.semaphore); + int semaphore_delete(semaphore s, const char *name){ + int ret = sem_destroy(s.semaphore, name); if (ret == 0) shared_mem_dealloc(s.semaphore, sizeof(sem_t)); return ret; } diff --git a/src/ipc_semaphore.h b/src/ipc_semaphore.h index f9c9bbf..2c14d01 100644 --- a/src/ipc_semaphore.h +++ b/src/ipc_semaphore.h @@ -1,7 +1,7 @@ #ifndef __SYNCD_SEMAPHORE__ #define __SYNCD_SEMAPHORE__ -#ifdef _WINDOWS_ +#ifdef WIN32 #include @@ -22,8 +22,8 @@ #endif // this is for getting shared memory semaphores. -semaphore semaphore_create(unsigned int max); -int semaphore_delete(semaphore s); +semaphore semaphore_create(unsigned int max, const char * name); +int semaphore_delete(semaphore s, const char * name); int semaphore_wait (semaphore s); int semaphore_post (semaphore s); diff --git a/src/shared_memory.c b/src/shared_memory.c index 5a13520..f69f594 100644 --- a/src/shared_memory.c +++ b/src/shared_memory.c @@ -1,24 +1,85 @@ #include "shared_memory.h" -#include #include /* For mode constants */ -#include /* For O_* constants */ -#include #include -#include #include #include -void * shared_mem_alloc(size_t size){ - char name[14]; - time_t now = time(0); - sprintf(name, "/%10ld", (long int) now % 10000000000); - int fd = shm_open(name, O_CREAT|O_RDWR, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP); - ftruncate(fd, size); - void * ret = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0); - shm_unlink(name); - return ret; -} +#ifdef WIN32 +#include + + typedef struct { + HANDLE hMapFile; + void * mem; + char * name; + } sm_obj; + + sm_obj * sm_mapping; + int sm_mapping_length; + + void * shared_mem_alloc(size_t size, const char * name){ + HANDLE hMapFile; + void * mem; + hMapFile = CreateFileMapping( + INVALID_HANDLE_VALUE, // use paging file + NULL, // default security + PAGE_READWRITE, // read/write access + 0, // maximum object size (high-order DWORD) + size, // maximum object size (low-order DWORD) + name + ); + if (hMapFile == NULL){ + // We have a problem. + return NULL; + } + mem = (void *) MapViewOfFile(hMapFile, // handle to map object + FILE_MAP_ALL_ACCESS, // read/write permission + 0, + 0, + size + ); + + sm_obj m; + m.hMapFile = hMapFile; + m.mem = mem; + m.name = strdup(name); + + sm_mapping = realloc(sm_mapping, sizeof(sm_obj) * ++sm_mapping_length); + sm_mapping[sm_mapping_length-1] = m; + + return (void *) mem; + } + + void shared_mem_dealloc(void* mem, size_t len, const char * name){ + // TODO: free the sm_obj, collapsing the array. + int i; + sm_obj m; + for (i = 0; i < sm_mapping_length; i++){ + m = sm_mapping[i]; + if (strcmp(m.name,name) == 0) break; + } + + UnmapViewOfFile((LPTSTR) mem); + CloseHandle(m.hMapFile); + free(m.name); + m.name = NULL; + m.mem = NULL; + } + +#else + +#include +#include /* For O_* constants */ +#include -void shared_mem_dealloc(void* mem, int len){ - munmap(mem, len); -} + void * shared_mem_alloc(size_t size, const char * name){ + int fd = shm_open(name, O_CREAT|O_RDWR, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP); + ftruncate(fd, size); + void * ret = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0); + return ret; + } + + void shared_mem_dealloc(void* mem, int len, const char * name){ + munmap(mem, len); + shm_unlink(name); + } +#endif diff --git a/src/shared_memory.h b/src/shared_memory.h index d345f74..4ee4d0a 100644 --- a/src/shared_memory.h +++ b/src/shared_memory.h @@ -2,7 +2,7 @@ #define SHARED_MEM_H_ #include -void * shared_mem_alloc(size_t size); -void shared_mem_dealloc(void* mem, int len); +void * shared_mem_alloc(size_t size, const char * name); +void shared_mem_dealloc(void* mem, size_t len, const char * name); -#endif +#endif //SHARED_MEM_H_ From 98693369777d6b8dd784b3ab9232fe53cee2eca5 Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 28 May 2015 12:14:18 -0500 Subject: [PATCH 05/49] Got it to build on Linux --- CMakeLists.txt | 5 +++-- libexec/dropbox.c | 3 ++- libexec/gdrive.c | 4 ++-- libexec/linuxfs.c | 2 +- librest/CMakeLists.txt | 1 + src/CMakeLists.txt | 9 +++++++-- src/ipc_semaphore.c | 4 ++-- src/log.c | 3 ++- src/shared_memory.c | 22 +++++++++++----------- 9 files changed, 31 insertions(+), 22 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index c788f80..38a1641 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -7,7 +7,8 @@ include(CheckIncludeFiles) include(CheckFunctionExists) find_package(JSONC) -find_package(THREADS) +set(THREADS_PREFER_PTHREAD_FLAG ON) +find_package(Threads) include_directories(${JSONC_INCLUDE_DIRS}) @@ -25,4 +26,4 @@ add_subdirectory(libgdrive) add_subdirectory(libexec) add_subdirectory(src) -CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/cmake-config.h.in ${CMAKE_CURRENT_BINARY_DIR}/config.h) \ No newline at end of file +CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/cmake-config.h.in ${CMAKE_CURRENT_BINARY_DIR}/config.h) diff --git a/libexec/dropbox.c b/libexec/dropbox.c index 0458cbf..e16b934 100644 --- a/libexec/dropbox.c +++ b/libexec/dropbox.c @@ -20,6 +20,7 @@ */ #include "dropbox.h" +#include /* globals */ char * client_key = "gmq6fs74fuw1ead"; char * client_secret = "ia87pt0ep6dvb7y"; @@ -29,7 +30,7 @@ utilities utils; json_object * config; json_object * cache; -#ifndef HAVE_WARN_H +#ifndef HAVE_WAIT_H int WEXITSTATUS(int in){ args.log(LOGARGS, "COMPAT_WEXITSTATUS in=%d, %x", in,in ); return in; diff --git a/libexec/gdrive.c b/libexec/gdrive.c index 6ebc019..100a2b4 100644 --- a/libexec/gdrive.c +++ b/libexec/gdrive.c @@ -18,7 +18,7 @@ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ - + #include "gdrive.h" bool check_error(json_object* obj); @@ -32,7 +32,7 @@ utilities local_utils; utilities utils; init_args args; -#ifndef HAVE_WARN_H +#ifndef HAVE_WAIT_H int WEXITSTATUS(int in){ args.log(LOGARGS, "COMPAT_WEXITSTATUS in=%d, %x", in,in ); return in; diff --git a/libexec/linuxfs.c b/libexec/linuxfs.c index d7a7894..cb904f9 100644 --- a/libexec/linuxfs.c +++ b/libexec/linuxfs.c @@ -20,7 +20,7 @@ */ #include - +#include "syncfs.h" static int inotify_fd; static char** watchpoints; diff --git a/librest/CMakeLists.txt b/librest/CMakeLists.txt index 316c4ed..1ef11e9 100644 --- a/librest/CMakeLists.txt +++ b/librest/CMakeLists.txt @@ -2,4 +2,5 @@ find_package(CURL) include_directories(${CURL_INCLUDE_DIRS}) add_library(rest rest.c buffer.c) +set_property(TARGET rest PROPERTY POSITION_INDEPENDENT_CODE ON) target_link_libraries(rest LINK_PUBLIC ${CURL_LIBRARIES}) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index e72caf7..fde39d4 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -4,10 +4,15 @@ include_directories("${LTDL_INCLUDE_DIRS}") IF(WIN32) find_package(mman) + set(SHARED_MEM "${MMAN_LIBRARIES}") +ELSEIF(UNIX AND NOT APPLE) + set(SHARED_MEM "rt") +ELSE() + set(SHARED_MEM "") ENDIF() add_executable(syncd syncd.c cache.c ipc_semaphore.c shared_memory.c json_helper.c log.c) -target_link_libraries(syncd LINK_PRIVATE ${CMAKE_THREAD_LIBS_INIT} ${LTDL_LIBRARIES} ${JSONC_LIBRARIES} ${MMAN_LIBRARIES}) +target_link_libraries(syncd LINK_PRIVATE ${CMAKE_THREAD_LIBS_INIT} ${LTDL_LIBRARIES} ${JSONC_LIBRARIES} ${SHARED_MEM}) add_executable(testPlugin testPlugin.c cache.c ipc_semaphore.c shared_memory.c json_helper.c log.c) -target_link_libraries(testPlugin LINK_PRIVATE ${CMAKE_THREAD_LIBS_INIT} ${LTDL_LIBRARIES} ${JSONC_LIBRARIES} ${MMAN_LIBRARIES}) +target_link_libraries(testPlugin LINK_PRIVATE ${CMAKE_THREAD_LIBS_INIT} ${LTDL_LIBRARIES} ${JSONC_LIBRARIES} ${SHARED_MEM}) diff --git a/src/ipc_semaphore.c b/src/ipc_semaphore.c index 7222acc..f9b85fe 100644 --- a/src/ipc_semaphore.c +++ b/src/ipc_semaphore.c @@ -34,8 +34,8 @@ } int semaphore_delete(semaphore s, const char *name){ - int ret = sem_destroy(s.semaphore, name); - if (ret == 0) shared_mem_dealloc(s.semaphore, sizeof(sem_t)); + int ret = sem_destroy(s.semaphore); + if (ret == 0) shared_mem_dealloc(s.semaphore, sizeof(sem_t), name); return ret; } diff --git a/src/log.c b/src/log.c index 8a63cc6..f551479 100644 --- a/src/log.c +++ b/src/log.c @@ -1,5 +1,6 @@ #include "log.h" #include +#include #include @@ -17,7 +18,7 @@ void logging_init(const char *filename) // backup stdout and stderr __stderr_fd = dup(fileno(stderr)); __stdout_fd = dup(fileno(stdout)); - + __stdout = fdopen(__stdout_fd, "a"); __stderr = fdopen(__stderr_fd, "a"); diff --git a/src/shared_memory.c b/src/shared_memory.c index f69f594..1754704 100644 --- a/src/shared_memory.c +++ b/src/shared_memory.c @@ -12,10 +12,10 @@ void * mem; char * name; } sm_obj; - + sm_obj * sm_mapping; int sm_mapping_length; - + void * shared_mem_alloc(size_t size, const char * name){ HANDLE hMapFile; void * mem; @@ -37,18 +37,18 @@ 0, size ); - + sm_obj m; m.hMapFile = hMapFile; m.mem = mem; m.name = strdup(name); - + sm_mapping = realloc(sm_mapping, sizeof(sm_obj) * ++sm_mapping_length); sm_mapping[sm_mapping_length-1] = m; - - return (void *) mem; + + return (void *) mem; } - + void shared_mem_dealloc(void* mem, size_t len, const char * name){ // TODO: free the sm_obj, collapsing the array. int i; @@ -57,14 +57,14 @@ m = sm_mapping[i]; if (strcmp(m.name,name) == 0) break; } - + UnmapViewOfFile((LPTSTR) mem); CloseHandle(m.hMapFile); free(m.name); m.name = NULL; m.mem = NULL; } - + #else #include @@ -77,8 +77,8 @@ void * ret = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0); return ret; } - - void shared_mem_dealloc(void* mem, int len, const char * name){ + + void shared_mem_dealloc(void* mem, size_t len, const char * name){ munmap(mem, len); shm_unlink(name); } From a5b4b91283a3282ab36887c289702cb2d2c26bf6 Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 28 May 2015 13:41:04 -0500 Subject: [PATCH 06/49] install target --- CMakeLists.txt | 3 ++- cmake-config.h.in | 5 +++++ libexec/CMakeLists.txt | 8 ++++++-- src/CMakeLists.txt | 2 ++ src/syncd.c | 12 ++++++------ 5 files changed, 21 insertions(+), 9 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 38a1641..9c47ded 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -18,8 +18,9 @@ check_include_files("sys/wait.h" HAVE_WAIT_H) check_function_exists(fork HAVE_FORK) include_directories("${CMAKE_BINARY_DIR}") - include_directories("${CMAKE_CURRENT_LIST_DIR}") + +set(PLUGIN_DIR "${CMAKE_INSTALL_PREFIX}/lib/syncd/plugins") add_subdirectory(librest) add_subdirectory(libdropbox) add_subdirectory(libgdrive) diff --git a/cmake-config.h.in b/cmake-config.h.in index 6c68637..b8eabfa 100644 --- a/cmake-config.h.in +++ b/cmake-config.h.in @@ -1,4 +1,9 @@ +// Set Up Booleans #cmakedefine HAVE_INOTIFY_H 1 #cmakedefine HAVE_ERR_H 1 #cmakedefine HAVE_FORK 1 #cmakedefine HAVE_WAIT_H 1 + +// Set Up Directories +#define LIBDIR "${PLUGIN_DIR}" +#define PLUGIN_EXT "${CMAKE_SHARED_MODULE_SUFFIX}" diff --git a/libexec/CMakeLists.txt b/libexec/CMakeLists.txt index a212cf2..8fe6cc9 100644 --- a/libexec/CMakeLists.txt +++ b/libexec/CMakeLists.txt @@ -17,8 +17,12 @@ if(WIN32) set (COMPAT ${COMPAT} "strptime.c") endif() -add_library(syncDrobBox MODULE dropbox.c ${COMPAT} ../src/plugin.c ../src/json_helper.c) -target_link_libraries(syncDrobBox LINK_PRIVATE dropbox) +add_library(syncDropBox MODULE dropbox.c ${COMPAT} ../src/plugin.c ../src/json_helper.c) +target_link_libraries(syncDropBox LINK_PRIVATE dropbox) add_library(syncGoogleDrive MODULE gdrive.c ${COMPAT} gdrive_cache.c ../src/plugin.c ../src/json_helper.c) target_link_libraries(syncGoogleDrive LINK_PRIVATE gdrive) + + +install(TARGETS syncGoogleDrive syncDropBox syncFile + LIBRARY DESTINATION lib/syncd/plugins) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index fde39d4..24504ac 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -16,3 +16,5 @@ target_link_libraries(syncd LINK_PRIVATE ${CMAKE_THREAD_LIBS_INIT} ${LTDL_LIBRAR add_executable(testPlugin testPlugin.c cache.c ipc_semaphore.c shared_memory.c json_helper.c log.c) target_link_libraries(testPlugin LINK_PRIVATE ${CMAKE_THREAD_LIBS_INIT} ${LTDL_LIBRARIES} ${JSONC_LIBRARIES} ${SHARED_MEM}) + +install(TARGETS syncd RUNTIME DESTINATION bin) diff --git a/src/syncd.c b/src/syncd.c index 9ea6acb..1608a82 100644 --- a/src/syncd.c +++ b/src/syncd.c @@ -27,7 +27,7 @@ #include #include #include "log.h" - +#include typedef struct { lt_dlhandle ptr; const char * prefix; @@ -42,18 +42,18 @@ json_object * rules; #define LIBDIR "plugins" #endif -#ifndef HAVE_FORK +#ifndef HAVE_FORK #include #define fork() pseudo_fork(i,argv[0]) int pseudo_fork(int plugin_num, char * exec_name){ char pArg[5]; STARTUPINFO si; PROCESS_INFORMATION pi; - + memset( &si, 0, sizeof(si) ); si.cb = sizeof(si); memset( &pi, 0, sizeof(pi) ); - + sprintf(pArg,"-p %d",plugin_num); printf("running '%s %s'\n",exec_name,pArg); //int error = spawnl(P_NOWAIT,exec_name,exec_name,"-p",pnum); @@ -64,7 +64,7 @@ json_object * rules; FALSE, // Set handle inheritance to FALSE 0, // No creation flags NULL, // Use parent's environment block - NULL, // Use parent's starting directory + NULL, // Use parent's starting directory &si, // Pointer to STARTUPINFO structure &pi // Pointer to PROCESS_INFORMATION structure ); @@ -210,7 +210,7 @@ int cb(const char * path, int mask){ lt_dlhandle loadPlugin(const char * filename ){ const char * ext = strrchr(filename, '.'); - if(strcmp(ext, ".la") != 0) return NULL; + if(strcmp(ext, PLUGIN_EXT) != 0) return NULL; lt_dlhandle out = lt_dlopen(filename); const char * (*get_prefix)() = (const char * (*)()) lt_dlsym (out, "get_prefix"); if ( get_prefix != NULL){ From 04cadf97c49316ffbf47a243c0f200232396e650 Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 28 May 2015 17:27:14 -0400 Subject: [PATCH 07/49] incorrect export name --- libexec/dropbox.h | 2 +- libexec/gdrive.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/libexec/dropbox.h b/libexec/dropbox.h index 7fdd129..e9b97f0 100644 --- a/libexec/dropbox.h +++ b/libexec/dropbox.h @@ -33,7 +33,7 @@ const char * EXPORT_SHARED init (init_args ); void EXPORT_SHARED sync_listen (int(*)(const char*,int) ); -FILE * EXPORT_SHARED sync_open_file (const char* ); +FILE * EXPORT_SHARED sync_open (const char* ); int EXPORT_SHARED sync_write (const char*,FILE * ); int EXPORT_SHARED sync_rm (const char* ); int EXPORT_SHARED sync_mv (const char*,const char* ); diff --git a/libexec/gdrive.h b/libexec/gdrive.h index bc614a2..6571181 100644 --- a/libexec/gdrive.h +++ b/libexec/gdrive.h @@ -35,7 +35,7 @@ const char * EXPORT_SHARED init (init_args ); void EXPORT_SHARED sync_listen (int(*)(const char*,int) ); -FILE * EXPORT_SHARED sync_open_file (const char* ); +FILE * EXPORT_SHARED sync_open (const char* ); int EXPORT_SHARED sync_write (const char*,FILE * ); int EXPORT_SHARED sync_rm (const char* ); int EXPORT_SHARED sync_mv (const char*,const char* ); From 8ed3ffb9af652f7dc173ed290e292ebb72476bb9 Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Sat, 30 May 2015 13:07:31 -0500 Subject: [PATCH 08/49] a few edits for automake to work --- CMakeLists.txt | 2 +- autogen.sh | 3 ++- configure.ac | 31 +++++++++++++++++++------------ libdropbox/.gitignore | 1 - libdropbox/CMakeLists.txt | 6 ++++++ 5 files changed, 28 insertions(+), 15 deletions(-) mode change 100644 => 100755 autogen.sh create mode 100644 libdropbox/CMakeLists.txt diff --git a/CMakeLists.txt b/CMakeLists.txt index 9c47ded..599ddbe 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -12,7 +12,7 @@ find_package(Threads) include_directories(${JSONC_INCLUDE_DIRS}) -check_include_files("inotify.h" HAVE_INOTIFY_H) +check_include_files("sys/inotify.h" HAVE_INOTIFY_H) check_include_files("err.h" HAVE_ERR_H) check_include_files("sys/wait.h" HAVE_WAIT_H) check_function_exists(fork HAVE_FORK) diff --git a/autogen.sh b/autogen.sh old mode 100644 new mode 100755 index de31cab..b9e756e --- a/autogen.sh +++ b/autogen.sh @@ -1,5 +1,6 @@ #!/bin/sh -libtoolize --ltdl -c -i +LIBTOOLIZE=$(which libtoolize) || $(which glibtoolize) +$LIBTOOLIZE --ltdl -c -i aclocal automake -a autoreconf --no-recursive diff --git a/configure.ac b/configure.ac index cad51ac..a5b3d3b 100644 --- a/configure.ac +++ b/configure.ac @@ -3,9 +3,8 @@ AC_PREREQ([2.69]) AC_INIT([syncd], [0.9], [bec8@students.calvin.edu]) -# remove b/c no config.h? -# AM_INIT_AUTOMAKE([1.14 foreign no-define]) -AM_INIT_AUTOMAKE([subdir-objects]) +#AM_INIT_AUTOMAKE([1.14 foreign no-define]) +AM_INIT_AUTOMAKE( foreign [subdir-objects]) AC_CONFIG_SRCDIR([config.h.in]) AC_CONFIG_HEADERS([config.h]) @@ -27,16 +26,24 @@ AC_CHECK_LIB([pthread], [pthread_create]) AC_CHECK_LIB([rest], [rest_build_param]) # json-c: AC_CHECK_LIB([json-c], [json_object_new_object]) -# libuv -AC_CHECK_LIB([uv], [uv_run]) #posix semaphore and shared memory AC_CHECK_LIB([rt], [shm_open]) # inotify: -AC_CHECK_HEADER(sys/inotify.h, - [AC_DEFINE(HAVE_INOTIFY_H, 1, - [Define to 1 if you have .])], - [AC_MSG_NOTICE([No inotify, using libuv as a backup])]) +AC_CHECK_HEADER(sys/inotify.h, + [ + AC_DEFINE( + HAVE_INOTIFY_H, 1, + [Define to 1 if you have .] + ) + AC_MSG_NOTICE([Using Inotify for FileSystem Events]) + ],[ + AC_MSG_NOTICE([No inotify, using libuv as a backup]) + AC_CHECK_LIB([uv], [uv_run]) + ]) + +#wait.h: +AC_CHECK_HEADERS([wait.h err.h]) # libtdl LT_CONFIG_LTDL_DIR([libltdl]) @@ -55,11 +62,11 @@ AC_TYPE_SIZE_T # Checks for library functions. AC_FUNC_FORK -AC_FUNC_MALLOC +#AC_FUNC_MALLOC AC_FUNC_MKTIME AC_FUNC_MMAP -AC_FUNC_REALLOC +#AC_FUNC_REALLOC AC_CHECK_FUNCS([ftruncate mkdir strchr strdup strerror]) +AC_DEFINE(PLUGIN_EXT, ".la", [extention to look for for plugins]) AC_OUTPUT(Makefile librest/Makefile libdropbox/Makefile libgdrive/Makefile libexec/Makefile src/Makefile ) - diff --git a/libdropbox/.gitignore b/libdropbox/.gitignore index 8c37db6..92ceaf1 100644 --- a/libdropbox/.gitignore +++ b/libdropbox/.gitignore @@ -3,6 +3,5 @@ dropbox *.o *.dll *.so -*.txt *.a *.zip diff --git a/libdropbox/CMakeLists.txt b/libdropbox/CMakeLists.txt new file mode 100644 index 0000000..2705cd6 --- /dev/null +++ b/libdropbox/CMakeLists.txt @@ -0,0 +1,6 @@ +include_directories("${CMAKE_ROOT}") + +add_library(dropbox dropbox_api.c) +set_property(TARGET dropbox PROPERTY POSITION_INDEPENDENT_CODE ON) +target_link_libraries(dropbox LINK_PRIVATE rest json-c) + From 5bab8805219a76a08ac4f26b3d0a9e4867dcc283 Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Mon, 1 Jun 2015 06:14:27 -0500 Subject: [PATCH 09/49] cleaned up all build warnings --- README => README.md | 0 libdropbox/CMakeLists.txt | 6 ++++-- libdropbox/dropbox_api.c | 14 +++++++------- libdropbox/dropbox_api.h | 15 +++++++-------- libgdrive/CMakeLists.txt | 3 +++ libgdrive/gdrive_api.c | 3 ++- libgdrive/gdrive_main.c | 12 ++++++------ src/syncd.c | 1 - 8 files changed, 29 insertions(+), 25 deletions(-) rename README => README.md (100%) diff --git a/README b/README.md similarity index 100% rename from README rename to README.md diff --git a/libdropbox/CMakeLists.txt b/libdropbox/CMakeLists.txt index 2705cd6..075037f 100644 --- a/libdropbox/CMakeLists.txt +++ b/libdropbox/CMakeLists.txt @@ -1,6 +1,8 @@ include_directories("${CMAKE_ROOT}") +#add_executable(dropbox_main dropbox_api.c dropbox_main.c) +#target_link_libraries(dropbox_main LINK_PRIVATE rest ${JSONC_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ) + add_library(dropbox dropbox_api.c) set_property(TARGET dropbox PROPERTY POSITION_INDEPENDENT_CODE ON) -target_link_libraries(dropbox LINK_PRIVATE rest json-c) - +target_link_libraries(dropbox LINK_PRIVATE rest ${JSONC_LIBRARIES}) diff --git a/libdropbox/dropbox_api.c b/libdropbox/dropbox_api.c index a248946..dcd0a0c 100644 --- a/libdropbox/dropbox_api.c +++ b/libdropbox/dropbox_api.c @@ -28,7 +28,7 @@ #include "dropbox_urls.h" -FILE * db_files_get(char* path, const char* access_token){ +FILE * db_files_get(const char* path, const char* access_token){ char* params[2]; char * url = malloc(strlen(path) + strlen(FILES_GET) + 2); @@ -42,7 +42,7 @@ FILE * db_files_get(char* path, const char* access_token){ return file; } -json_object * db_files_put(char* path, const char* access_token, FILE * input_file){ +json_object * db_files_put(const char* path, const char* access_token, FILE * input_file){ char* params[2]; char * url = malloc(strlen(path) + strlen(FILES_PUT) + 2); @@ -60,7 +60,7 @@ json_object * db_files_put(char* path, const char* access_token, FILE * input_fi return response; } -json_object * db_metadata (char* path, const char* access_token, bool list){ +json_object * db_metadata (const char* path, const char* access_token, bool list){ char * params[3]; int i; rest_build_param(¶ms[0],"access_token",access_token); @@ -80,7 +80,7 @@ json_object * db_metadata (char* path, const char* access_token, bool list){ return response; } -json_object * db_longpoll (char* cursor, int timeout){ +json_object * db_longpoll (const char* cursor, int timeout){ char * params[3]; int i; if (timeout > 480) timeout = 480;// max allowed @@ -146,7 +146,7 @@ const char * db_authorize_token (char* token, char * client_id, char* client_sec return NULL; } -json_object * db_mkdir(char* name, const char * access_token){ +json_object * db_mkdir(const char* name, const char * access_token){ char * params[4]; params[0] = "root=dropbox"; rest_build_param(¶ms[1], "path",name); @@ -162,7 +162,7 @@ json_object * db_mkdir(char* name, const char * access_token){ return response; } -json_object * db_mv(char* from, char * to, const char * access_token){ +json_object * db_mv(const char* from, const char * to, const char * access_token){ char * params[5]; params[0] = "root=dropbox"; rest_build_param(¶ms[1], "from_path",from); @@ -180,7 +180,7 @@ json_object * db_mv(char* from, char * to, const char * access_token){ return response; } -json_object * db_rm(char* name, const char * access_token){ +json_object * db_rm(const char* name, const char * access_token){ char * params[4]; params[0] = "root=dropbox"; rest_build_param(¶ms[1], "path",name); diff --git a/libdropbox/dropbox_api.h b/libdropbox/dropbox_api.h index b261c84..1358830 100644 --- a/libdropbox/dropbox_api.h +++ b/libdropbox/dropbox_api.h @@ -27,14 +27,13 @@ #include "dropbox_urls.h" #include "librest/rest.h" -FILE * db_files_get(char* path, const char* access_token); -json_object * db_files_put(char* path, const char* access_token, FILE * input_file); -json_object * db_metadata (char* path, const char* access_token, bool list); +FILE * db_files_get(const char* path, const char* access_token); +json_object * db_files_put(const char* path, const char* access_token, FILE * input_file); +json_object * db_metadata (const char* path, const char* access_token, bool list); json_object * db_delta (char* cursor, const char* access_token); -json_object * db_longpoll (char* cursor,int timeout); +json_object * db_longpoll (const char* cursor,int timeout); const char * db_authorize_token (char* token, char * client_id, char* client_secret); -json_object * db_mkdir(char * name, const char * access_token); -json_object * db_mv(char * from,char * to, const char * access_token); -json_object * db_rm(char * name, const char * access_token); +json_object * db_mkdir(const char * name, const char * access_token); +json_object * db_mv(const char * from, const char * to, const char * access_token); +json_object * db_rm(const char * name, const char * access_token); #endif - diff --git a/libgdrive/CMakeLists.txt b/libgdrive/CMakeLists.txt index 7661463..2183d9c 100644 --- a/libgdrive/CMakeLists.txt +++ b/libgdrive/CMakeLists.txt @@ -1,5 +1,8 @@ include_directories("${CMAKE_ROOT}") +#add_executable(gdrive_main gdrive_main.c gdrive_api.c) +#target_link_libraries(gdrive_main LINK_PRIVATE rest ${JSONC_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT}) + add_library(gdrive gdrive_api.c) set_property(TARGET gdrive PROPERTY POSITION_INDEPENDENT_CODE ON) target_link_libraries(gdrive LINK_PRIVATE rest ${JSONC_LIBRARIES}) diff --git a/libgdrive/gdrive_api.c b/libgdrive/gdrive_api.c index 6120ab3..3d1fcc4 100644 --- a/libgdrive/gdrive_api.c +++ b/libgdrive/gdrive_api.c @@ -459,7 +459,8 @@ json_object * gdrive_files_list_children(char * id, int pageToken){ buffer resp = rest_get_buffer(params,url); json_object * response = json_tokener_parse(resp.data); - json_object * list = json_object_object_get(response, "items"); + json_object * list; + json_object_object_get_ex(response, "items", &list); int i; for (i = 0; i < json_object_array_length(list); i++){ const char * folder_id = JSON_GET_STRING(json_object_array_get_idx(list,i),"id"); diff --git a/libgdrive/gdrive_main.c b/libgdrive/gdrive_main.c index 4d354f7..cd96269 100644 --- a/libgdrive/gdrive_main.c +++ b/libgdrive/gdrive_main.c @@ -1,5 +1,5 @@ #include "gdrive_api.h" -#define REFRESH_TOKEN "1/8obRmFxvhhebWSCYckmw_AfUlfTD-ERnwvoro8tMAKI" +#define REFRESH_TOKEN "1/8obRmFxvhhebWSCYckmw_AfUlfTD-ERnwvoro8tMAKI" int main(int argc, char ** argv){ json_object * cache = json_object_from_file("./cache.json"); @@ -31,11 +31,11 @@ int main(int argc, char ** argv){ json_object_put(gdrive_files_list("title='test' and mimeType = 'application/vnd.google-apps.folder'",0));*/ char * next_page_token = NULL; do { - json_object * changes = gdrive_get_changes(next_page_token,0,10); + json_object * changes = gdrive_get_changes(next_page_token,0,10,false, false); // printf("%s\n",json_object_to_json_string_ext(changes,JSON_C_TO_STRING_PRETTY)); free(next_page_token); next_page_token = JSON_GET_STRING(changes,"nextPageToken"); - if (next_page_token != NULL) next_page_token = strdup(next_page_token); + if (next_page_token != NULL) next_page_token = strdup(next_page_token); int i; json_object * items; if (json_object_object_get_ex(changes, "items",&items)){ @@ -52,11 +52,11 @@ int main(int argc, char ** argv){ JSON_GET_STRING(change,"createdDate"), modified ) == 0; - bool is_dir = strcmp( + bool is_dir = strcmp( JSON_GET_STRING(change,"mimeType"), "application/vnd.google-apps.folder" - ) == 0; - printf("file id: '%s', title: '%s%s' %s on %s\n", + ) == 0; + printf("file id: '%s', title: '%s%s' %s on %s\n", id, title, is_dir?"/":"", diff --git a/src/syncd.c b/src/syncd.c index 1608a82..900bafb 100644 --- a/src/syncd.c +++ b/src/syncd.c @@ -22,7 +22,6 @@ #include "os.h" #include #include -#include "../libltdl/ltdl.h" #include #include #include From d336b385316b261287acd127d654ee5aa6d17b35 Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Mon, 1 Jun 2015 06:14:51 -0500 Subject: [PATCH 10/49] first step in moving to dynamically sized cache. --- src/cache.c | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/src/cache.c b/src/cache.c index de37d4e..84d61d1 100644 --- a/src/cache.c +++ b/src/cache.c @@ -29,6 +29,7 @@ #include #include #include "ipc_semaphore.h" +#include "shared_memory.h" #include "log.h" #include @@ -50,7 +51,7 @@ json_object * config; char * cacheFile; int cacheFD; long long int * cacheVersion; -size_t cacheLength; +size_t * cacheLength; semaphore cache_semaphore; semaphore config_semaphore; @@ -63,14 +64,15 @@ void push_cache(); /* public functions */ void cache_init(){ //set up shared memory - cacheLength = 10 * 1024 * 1024; // 100 MB for now. + cacheLength = (size_t *) shared_mem_alloc(sizeof(size_t), "SYNCD\\cache_length"); + * cacheLength = 10 * 1024 * 1024; // 10 MB for now. char path[PATH_MAX]; strcpy(path, getenv("HOME")); strcat(path, "/.cache/syncd/cache.json"); int cacheFD = open(path,O_CREAT|O_RDWR, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP); - ftruncate(cacheFD,cacheLength); + ftruncate(cacheFD,*cacheLength); logging_log(LOGARGS,"fd = %d\n",cacheFD); - cacheFile = (char *) mmap(NULL, cacheLength, + cacheFile = (char *) mmap(NULL, *cacheLength, PROT_READ | PROT_WRITE, MAP_FILE|MAP_SHARED, cacheFD, 0); if (cacheFile == MAP_FAILED ) errx(1,"failed"); // setup semaphores. @@ -79,7 +81,7 @@ void cache_init(){ } void cache_clear(){ - munmap(cacheFile, cacheLength); + munmap(cacheFile, *cacheLength); close(cacheFD); semaphore_delete(cache_semaphore, "SYNCD\\cache"); semaphore_delete(config_semaphore, "SYNCD\\cache"); @@ -213,7 +215,7 @@ void push_cache(){ const char * string = ""; if (cache != NULL ) string = json_object_to_json_string(cache); logging_log(LOGARGS,"cache.json length = %d\n",(int)strlen(string)); - if (strlen(string) > cacheLength){ + if (strlen(string) > *cacheLength){ logging_log(LOGARGS,"the string is too long\n"); } semaphore_wait(cache_semaphore); From 14fec1b0c78d2e95a38d10647e59ff2387ee806c Mon Sep 17 00:00:00 2001 From: PaulMartin Date: Thu, 11 Jun 2015 18:43:52 -0700 Subject: [PATCH 11/49] builds, and runs mostly on MAC --- libexec/dropbox.h | 6 +++--- libexec/gdrive.c | 1 - libexec/gdrive.h | 7 ++++--- libexec/gdrive_cache.c | 3 ++- libexec/syncfs.h | 5 ++++- libgdrive/gdrive_api.c | 3 +-- src/syncd.c | 16 ++++++++++++++++ src/testPlugin.c | 8 +++++--- 8 files changed, 35 insertions(+), 14 deletions(-) diff --git a/libexec/dropbox.h b/libexec/dropbox.h index e9b97f0..137482b 100644 --- a/libexec/dropbox.h +++ b/libexec/dropbox.h @@ -1,3 +1,4 @@ +#include #define _XOPEN_SOURCE 500 #define XOPEN_SOURCE #include @@ -5,7 +6,6 @@ #include #include #include -#include #include "../libdropbox/dropbox_api.h" #define PLUGIN_PREFIX "dropbox://" @@ -17,7 +17,7 @@ #define EXPORT_SHARED __declspec(dllexport) #else #include - #define EXPORT_SHARED + #define EXPORT_SHARED #endif #if defined(_WIN32) @@ -40,4 +40,4 @@ int EXPORT_SHARED sync_mv (const char*,const char* ); void EXPORT_SHARED watch_dir (const char* ); int EXPORT_SHARED sync_mkdir (const char* ); void EXPORT_SHARED sync_unload ( ); -const char * EXPORT_SHARED get_prefix ( ); \ No newline at end of file +const char * EXPORT_SHARED get_prefix ( ); diff --git a/libexec/gdrive.c b/libexec/gdrive.c index 100a2b4..0dba02a 100644 --- a/libexec/gdrive.c +++ b/libexec/gdrive.c @@ -20,7 +20,6 @@ */ #include "gdrive.h" - bool check_error(json_object* obj); char * mkdirP(const char * path); diff --git a/libexec/gdrive.h b/libexec/gdrive.h index 6571181..92f96d9 100644 --- a/libexec/gdrive.h +++ b/libexec/gdrive.h @@ -1,5 +1,7 @@ +#include #define _XOPEN_SOURCE 500 #include +#include #include "../libgdrive/gdrive_api.h" #include "../src/os.h" #include "../src/json_helper.h" @@ -20,14 +22,13 @@ #define __GLOBAL_CLIENT_SECRET "gcyc89d--P9nUb1KagVeV496" #define __GLOBAL_CLIENT_ID "969830472849-93kt0dqjevn8jgr3g6erissiocdhk2fo.apps.googleusercontent.com" -#define REFRESH_TOKEN "1/8obRmFxvhhebWSCYckmw_AfUlfTD-ERnwvoro8tMAKI" #if defined (WIN32) #define URL_OPEN_CMD "start \"\"" #define SILENT_CMD "" #elif defined(__APPLE__) && defined(__MACH__) #define URL_OPEN_CMD "open" -#define SILENT_CMD "2&>/dev/null" +#define SILENT_CMD "" #else #define URL_OPEN_CMD "sh -c 'xdg-open" #define SILENT_CMD "' 2&>/dev/null" @@ -42,4 +43,4 @@ int EXPORT_SHARED sync_mv (const char*,const char* ); void EXPORT_SHARED watch_dir (const char* ); int EXPORT_SHARED sync_mkdir (const char* ); void EXPORT_SHARED sync_unload ( ); -const char * EXPORT_SHARED get_prefix ( ); \ No newline at end of file +const char * EXPORT_SHARED get_prefix ( ); diff --git a/libexec/gdrive_cache.c b/libexec/gdrive_cache.c index 96ca871..7217024 100644 --- a/libexec/gdrive_cache.c +++ b/libexec/gdrive_cache.c @@ -1,10 +1,11 @@ +#include #define _XOPEN_SOURCE 500 #include "gdrive_cache.h" #include #include "../libgdrive/gdrive_api.h" #include "../src/os.h" #include -#include + #define PLUGIN_PREFIX "gdrive://" diff --git a/libexec/syncfs.h b/libexec/syncfs.h index 77d3fa0..a78dbb3 100644 --- a/libexec/syncfs.h +++ b/libexec/syncfs.h @@ -1,10 +1,10 @@ #ifndef _SYNCFS_H_ #define _SYNCFS_H_ +#include #define _XOPEN_SOURCE 500 #include #include -#include #include #include #include @@ -14,6 +14,9 @@ #include /* limits.h defines "PATH_MAX". */ #include +#ifndef PATH_MAX +#include +#endif #define PLUGIN_PREFIX "file://" #define PLUGIN_PREFIX_LEN 7 diff --git a/libgdrive/gdrive_api.c b/libgdrive/gdrive_api.c index 3d1fcc4..57f8508 100644 --- a/libgdrive/gdrive_api.c +++ b/libgdrive/gdrive_api.c @@ -1,10 +1,9 @@ +#include #define _XOPEN_SOURCE 500 #include "gdrive_api.h" #include #define __GLOBAL_CLIENT_ID "969830472849-93kt0dqjevn8jgr3g6erissiocdhk2fo.apps.googleusercontent.com" #define __GLOBAL_CLIENT_SECRET "gcyc89d--P9nUb1KagVeV496" -#define REFRESH_TOKEN "1/8obRmFxvhhebWSCYckmw_AfUlfTD-ERnwvoro8tMAKI" - /* globals*/ diff --git a/src/syncd.c b/src/syncd.c index 900bafb..e6e29af 100644 --- a/src/syncd.c +++ b/src/syncd.c @@ -27,6 +27,10 @@ #include #include "log.h" #include +#ifndef PATH_MAX +#include +#endif + typedef struct { lt_dlhandle ptr; const char * prefix; @@ -71,6 +75,18 @@ json_object * rules; return pi.dwProcessId; } #endif +#if defined(__APPLE__) && defined(__MACH__) + int pseudo_fork(int plugin_num, char* exec_name){ + char pnum[10]; + sprintf(pnum,"%d",plugin_num); + int pid = fork(); + logging_stdout ("Spawning process with PID %d\n", pid); + if (pid != 0) return pid; + execl(exec_name, exec_name, "-p", pnum, NULL); + return 0; + } + #define fork() pseudo_fork(i,argv[0]) +#endif json_object * getCacheDetails(int pnum, const char * path) { const char * plugin_prefix = plugins[pnum].prefix; diff --git a/src/testPlugin.c b/src/testPlugin.c index 25a73a7..d95beb8 100644 --- a/src/testPlugin.c +++ b/src/testPlugin.c @@ -5,6 +5,7 @@ int cb(const char * name, int mode){ printf("%s %d\n", name, mode); + return 0; } int main(int argc, char ** argv){ @@ -22,19 +23,19 @@ int main(int argc, char ** argv){ logging_stdout("Error loading '%s': %s\n", plugin_name, lt_dlerror()); return 1; } - + init = (S_INIT ) lt_dlsym(plugin, "init"); if (init == NULL){ logging_stdout("Error loading function 'init': %s\n", lt_dlerror()); return 1; } - + unload = (S_UNLOAD) lt_dlsym(plugin, "sync_unload"); if (unload == NULL){ logging_stdout("Error loading function 'sync_unload': %s\n", lt_dlerror()); return 1; } - + init_args args; args.event_callback = cb; args.log = logging_log; @@ -45,4 +46,5 @@ int main(int argc, char ** argv){ logging_close(); cache_clear(); puts(prefix); + return 0; } From 83211f915365ba608c4403ab0442cb9ef87b0cf4 Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 11 Jun 2015 21:50:50 -0400 Subject: [PATCH 12/49] testing deep copy --- libexec/dropbox.c | 2 - libexec/syncfs.c | 13 +- librest/CMakeLists.txt | 4 + librest/ca-certificates.crt | 4437 +++++++++++++++++++++++++++++++++++ src/json_helper.c | 14 +- src/json_helper.h | 2 +- src/syncd.c | 9 - 7 files changed, 4455 insertions(+), 26 deletions(-) create mode 100644 librest/ca-certificates.crt diff --git a/libexec/dropbox.c b/libexec/dropbox.c index e16b934..c8a3fe7 100644 --- a/libexec/dropbox.c +++ b/libexec/dropbox.c @@ -92,8 +92,6 @@ void update_cache(json_object * entry,const char *fname){ } size = json_object_new_int64(json_object_get_int64(size)); // copy args.log(LOGARGS,"size : %ld\n",json_object_get_int64(size)); - - // json_copy(&cfile, "rev", entry, json_object_new_string("blank")); { const char *rev; if ((rev = json_get_string(entry,"rev"))==NULL){ diff --git a/libexec/syncfs.c b/libexec/syncfs.c index ae7d1f8..c298841 100644 --- a/libexec/syncfs.c +++ b/libexec/syncfs.c @@ -34,7 +34,7 @@ int update_file_cache(char * filename, int update){ int metadata_changed = 0; struct stat details; args.log(LOGARGS,"filename = %s\n",filename); - json_object * cache_entry = json_object_get(utils.getFileCache(PLUGIN_PREFIX,filename)); + json_object * cache_entry = json_copy(utils.getFileCache(PLUGIN_PREFIX,filename),false); if (cache_entry == NULL){ metadata_changed = S_CREATE; args.log(LOGARGS,"cache was null for %s\n",filename); @@ -142,8 +142,9 @@ void watch_dir_recurse(char * dir_name){ } void watch_dir (char * dir_name){ - dir_name += PLUGIN_PREFIX_LEN; - sync_mkdir(dir_name); + args.log(LOGARGS, "syncFS:watch_dir(%s)\n", dir_name); + sync_mkdir(dir_name); + dir_name += PLUGIN_PREFIX_LEN; watch_dir_recurse(dir_name); } @@ -190,12 +191,12 @@ int mkpath(char* file_path, mode_t mode) { char* p; for (p=strchr(file_path+1, '/'); p; p=strchr(p+1, '/')) { *p='\0'; - + if (mkdir( - file_path + file_path #ifndef WIN32 ,mode -#endif +#endif )==-1) { if (errno!=EEXIST) { *p='/'; return -1; } } diff --git a/librest/CMakeLists.txt b/librest/CMakeLists.txt index 1ef11e9..d1381e6 100644 --- a/librest/CMakeLists.txt +++ b/librest/CMakeLists.txt @@ -4,3 +4,7 @@ include_directories(${CURL_INCLUDE_DIRS}) add_library(rest rest.c buffer.c) set_property(TARGET rest PROPERTY POSITION_INDEPENDENT_CODE ON) target_link_libraries(rest LINK_PUBLIC ${CURL_LIBRARIES}) + +if(WIN32) +install() +endif() diff --git a/librest/ca-certificates.crt b/librest/ca-certificates.crt new file mode 100644 index 0000000..d77c06e --- /dev/null +++ b/librest/ca-certificates.crt @@ -0,0 +1,4437 @@ +-----BEGIN CERTIFICATE----- +MIIDzzCCAregAwIBAgIDAWweMA0GCSqGSIb3DQEBBQUAMIGNMQswCQYDVQQGEwJB +VDFIMEYGA1UECgw/QS1UcnVzdCBHZXMuIGYuIFNpY2hlcmhlaXRzc3lzdGVtZSBp +bSBlbGVrdHIuIERhdGVudmVya2VociBHbWJIMRkwFwYDVQQLDBBBLVRydXN0LW5R +dWFsLTAzMRkwFwYDVQQDDBBBLVRydXN0LW5RdWFsLTAzMB4XDTA1MDgxNzIyMDAw +MFoXDTE1MDgxNzIyMDAwMFowgY0xCzAJBgNVBAYTAkFUMUgwRgYDVQQKDD9BLVRy +dXN0IEdlcy4gZi4gU2ljaGVyaGVpdHNzeXN0ZW1lIGltIGVsZWt0ci4gRGF0ZW52 +ZXJrZWhyIEdtYkgxGTAXBgNVBAsMEEEtVHJ1c3QtblF1YWwtMDMxGTAXBgNVBAMM +EEEtVHJ1c3QtblF1YWwtMDMwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB +AQCtPWFuA/OQO8BBC4SAzewqo51ru27CQoT3URThoKgtUaNR8t4j8DRE/5TrzAUj +lUC5B3ilJfYKvUWG6Nm9wASOhURh73+nyfrBJcyFLGM/BWBzSQXgYHiVEEvc+RFZ +znF/QJuKqiTfC0Li21a8StKlDJu3Qz7dg9MmEALP6iPESU7l0+m0iKsMrmKS1GWH +2WrX9IWf5DMiJaXlyDO6w8dB3F/GaswADm0yqLaHNgBid5seHzTLkDx4iHQF63n1 +k3Flyp3HaxgtPVxO59X4PzF9j4fsCiIvI+n+u33J4PTs63zEsMMtYrWacdaxaujs +2e3Vcuy+VwHOBVWf3tFgiBCzAgMBAAGjNjA0MA8GA1UdEwEB/wQFMAMBAf8wEQYD +VR0OBAoECERqlWdVeRFPMA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQUFAAOC +AQEAVdRU0VlIXLOThaq/Yy/kgM40ozRiPvbY7meIMQQDbwvUB/tOdQ/TLtPAF8fG +KOwGDREkDg6lXb+MshOWcdzUzg4NCmgybLlBMRmrsQd7TZjTXLDR8KdCoLXEjq/+ +8T/0709GAHbrAvv5ndJAlseIOrifEXnzgGWovR/TeIGgUUw3tKZdJXDRZslo+S4R +FGjxVJgIrCaSD96JntT6s3kr0qN51OyLrIdTaEJMUVF0HhsnLuP1Hyl0Te2v9+GS +mYHovjrHF1D2t8b8m7CKa9aIA5GPBnc6hQLdmNVDeD/GMBWsm2vLV7eJUYs66MmE +DNuxUCAKGkq6ahq97BvIxYSazQ== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIH0zCCBbugAwIBAgIIXsO3pkN/pOAwDQYJKoZIhvcNAQEFBQAwQjESMBAGA1UE +AwwJQUNDVlJBSVoxMRAwDgYDVQQLDAdQS0lBQ0NWMQ0wCwYDVQQKDARBQ0NWMQsw +CQYDVQQGEwJFUzAeFw0xMTA1MDUwOTM3MzdaFw0zMDEyMzEwOTM3MzdaMEIxEjAQ +BgNVBAMMCUFDQ1ZSQUlaMTEQMA4GA1UECwwHUEtJQUNDVjENMAsGA1UECgwEQUND +VjELMAkGA1UEBhMCRVMwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCb +qau/YUqXry+XZpp0X9DZlv3P4uRm7x8fRzPCRKPfmt4ftVTdFXxpNRFvu8gMjmoY +HtiP2Ra8EEg2XPBjs5BaXCQ316PWywlxufEBcoSwfdtNgM3802/J+Nq2DoLSRYWo +G2ioPej0RGy9ocLLA76MPhMAhN9KSMDjIgro6TenGEyxCQ0jVn8ETdkXhBilyNpA +lHPrzg5XPAOBOp0KoVdDaaxXbXmQeOW1tDvYvEyNKKGno6e6Ak4l0Squ7a4DIrhr +IA8wKFSVf+DuzgpmndFALW4ir50awQUZ0m/A8p/4e7MCQvtQqR0tkw8jq8bBD5L/ +0KIV9VMJcRz/RROE5iZe+OCIHAr8Fraocwa48GOEAqDGWuzndN9wrqODJerWx5eH +k6fGioozl2A3ED6XPm4pFdahD9GILBKfb6qkxkLrQaLjlUPTAYVtjrs78yM2x/47 +4KElB0iryYl0/wiPgL/AlmXz7uxLaL2diMMxs0Dx6M/2OLuc5NF/1OVYm3z61PMO +m3WR5LpSLhl+0fXNWhn8ugb2+1KoS5kE3fj5tItQo05iifCHJPqDQsGH+tUtKSpa +cXpkatcnYGMN285J9Y0fkIkyF/hzQ7jSWpOGYdbhdQrqeWZ2iE9x6wQl1gpaepPl +uUsXQA+xtrn13k/c4LOsOxFwYIRKQ26ZIMApcQrAZQIDAQABo4ICyzCCAscwfQYI +KwYBBQUHAQEEcTBvMEwGCCsGAQUFBzAChkBodHRwOi8vd3d3LmFjY3YuZXMvZmls +ZWFkbWluL0FyY2hpdm9zL2NlcnRpZmljYWRvcy9yYWl6YWNjdjEuY3J0MB8GCCsG +AQUFBzABhhNodHRwOi8vb2NzcC5hY2N2LmVzMB0GA1UdDgQWBBTSh7Tj3zcnk1X2 +VuqB5TbMjB4/vTAPBgNVHRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFNKHtOPfNyeT +VfZW6oHlNsyMHj+9MIIBcwYDVR0gBIIBajCCAWYwggFiBgRVHSAAMIIBWDCCASIG +CCsGAQUFBwICMIIBFB6CARAAQQB1AHQAbwByAGkAZABhAGQAIABkAGUAIABDAGUA +cgB0AGkAZgBpAGMAYQBjAGkA8wBuACAAUgBhAO0AegAgAGQAZQAgAGwAYQAgAEEA +QwBDAFYAIAAoAEEAZwBlAG4AYwBpAGEAIABkAGUAIABUAGUAYwBuAG8AbABvAGcA +7QBhACAAeQAgAEMAZQByAHQAaQBmAGkAYwBhAGMAaQDzAG4AIABFAGwAZQBjAHQA +cgDzAG4AaQBjAGEALAAgAEMASQBGACAAUQA0ADYAMAAxADEANQA2AEUAKQAuACAA +QwBQAFMAIABlAG4AIABoAHQAdABwADoALwAvAHcAdwB3AC4AYQBjAGMAdgAuAGUA +czAwBggrBgEFBQcCARYkaHR0cDovL3d3dy5hY2N2LmVzL2xlZ2lzbGFjaW9uX2Mu +aHRtMFUGA1UdHwROMEwwSqBIoEaGRGh0dHA6Ly93d3cuYWNjdi5lcy9maWxlYWRt +aW4vQXJjaGl2b3MvY2VydGlmaWNhZG9zL3JhaXphY2N2MV9kZXIuY3JsMA4GA1Ud +DwEB/wQEAwIBBjAXBgNVHREEEDAOgQxhY2N2QGFjY3YuZXMwDQYJKoZIhvcNAQEF +BQADggIBAJcxAp/n/UNnSEQU5CmH7UwoZtCPNdpNYbdKl02125DgBS4OxnnQ8pdp +D70ER9m+27Up2pvZrqmZ1dM8MJP1jaGo/AaNRPTKFpV8M9xii6g3+CfYCS0b78gU +JyCpZET/LtZ1qmxNYEAZSUNUY9rizLpm5U9EelvZaoErQNV/+QEnWCzI7UiRfD+m +AM/EKXMRNt6GGT6d7hmKG9Ww7Y49nCrADdg9ZuM8Db3VlFzi4qc1GwQA9j9ajepD +vV+JHanBsMyZ4k0ACtrJJ1vnE5Bc5PUzolVt3OAJTS+xJlsndQAJxGJ3KQhfnlms +tn6tn1QwIgPBHnFk/vk4CpYY3QIUrCPLBhwepH2NDd4nQeit2hW3sCPdK6jT2iWH +7ehVRE2I9DZ+hJp4rPcOVkkO1jMl1oRQQmwgEh0q1b688nCBpHBgvgW1m54ERL5h +I6zppSSMEYCUWqKiuUnSwdzRp+0xESyeGabu4VXhwOrPDYTkF7eifKXeVSUG7szA +h1xA2syVP1XgNce4hL60Xc16gwFy7ofmXx2utYXGJt/mwZrpHgJHnyqobalbz+xF +d3+YJ5oyXSrjhO7FmGYvliAd3djDJ9ew+f7Zfc3Qn48LFFhRny+Lwzgt3uiP1o2H +pPVWQxaZLPSkVrQ0uGE3ycJYgBugl6H8WY3pEfbRD0tVNEYqi4Y7 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFtTCCA52gAwIBAgIIYY3HhjsBggUwDQYJKoZIhvcNAQEFBQAwRDEWMBQGA1UE +AwwNQUNFRElDT00gUm9vdDEMMAoGA1UECwwDUEtJMQ8wDQYDVQQKDAZFRElDT00x +CzAJBgNVBAYTAkVTMB4XDTA4MDQxODE2MjQyMloXDTI4MDQxMzE2MjQyMlowRDEW +MBQGA1UEAwwNQUNFRElDT00gUm9vdDEMMAoGA1UECwwDUEtJMQ8wDQYDVQQKDAZF +RElDT00xCzAJBgNVBAYTAkVTMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKC +AgEA/5KV4WgGdrQsyFhIyv2AVClVYyT/kGWbEHV7w2rbYgIB8hiGtXxaOLHkWLn7 +09gtn70yN78sFW2+tfQh0hOR2QetAQXW8713zl9CgQr5auODAKgrLlUTY4HKRxx7 +XBZXehuDYAQ6PmXDzQHe3qTWDLqO3tkE7hdWIpuPY/1NFgu3e3eM+SW10W2ZEi5P +Grjm6gSSrj0RuVFCPYewMYWveVqc/udOXpJPQ/yrOq2lEiZmueIM15jO1FillUAK +t0SdE3QrwqXrIhWYENiLxQSfHY9g5QYbm8+5eaA9oiM/Qj9r+hwDezCNzmzAv+Yb +X79nuIQZ1RXve8uQNjFiybwCq0Zfm/4aaJQ0PZCOrfbkHQl/Sog4P75n/TSW9R28 +MHTLOO7VbKvU/PQAtwBbhTIWdjPp2KOZnQUAqhbm84F9b32qhm2tFXTTxKJxqvQU +fecyuB+81fFOvW8XAjnXDpVCOscAPukmYxHqC9FK/xidstd7LzrZlvvoHpKuE1XI +2Sf23EgbsCTBheN3nZqk8wwRHQ3ItBTutYJXCb8gWH8vIiPYcMt5bMlL8qkqyPyH +K9caUPgn6C9D4zq92Fdx/c6mUlv53U3t5fZvie27k5x2IXXwkkwp9y+cAS7+UEae +ZAwUswdbxcJzbPEHXEUkFDWug/FqTYl6+rPYLWbwNof1K1MCAwEAAaOBqjCBpzAP +BgNVHRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFKaz4SsrSbbXc6GqlPUB53NlTKxQ +MA4GA1UdDwEB/wQEAwIBhjAdBgNVHQ4EFgQUprPhKytJttdzoaqU9QHnc2VMrFAw +RAYDVR0gBD0wOzA5BgRVHSAAMDEwLwYIKwYBBQUHAgEWI2h0dHA6Ly9hY2VkaWNv +bS5lZGljb21ncm91cC5jb20vZG9jMA0GCSqGSIb3DQEBBQUAA4ICAQDOLAtSUWIm +fQwng4/F9tqgaHtPkl7qpHMyEVNEskTLnewPeUKzEKbHDZ3Ltvo/Onzqv4hTGzz3 +gvoFNTPhNahXwOf9jU8/kzJPeGYDdwdY6ZXIfj7QeQCM8htRM5u8lOk6e25SLTKe +I6RF+7YuE7CLGLHdztUdp0J/Vb77W7tH1PwkzQSulgUV1qzOMPPKC8W64iLgpq0i +5ALudBF/TP94HTXa5gI06xgSYXcGCRZj6hitoocf8seACQl1ThCojz2GuHURwCRi +ipZ7SkXp7FnFvmuD5uHorLUwHv4FB4D54SMNUI8FmP8sX+g7tq3PgbUhh8oIKiMn +MCArz+2UW6yyetLHKKGKC5tNSixthT8Jcjxn4tncB7rrZXtaAWPWkFtPF2Y9fwsZ +o5NjEFIqnxQWWOLcpfShFosOkYuByptZ+thrkQdlVV9SH686+5DdaaVbnG0OLLb6 +zqylfDJKZ0DcMDQj3dcEI2bw/FWAp/tmGYI1Z2JwOV5vx+qQQEQIHriy1tvuWacN +GHk0vFQYXlPKNFHtRQrmjseCNj6nOGOpMCwXEGCSn1WHElkQwg9naRHMTh5+Spqt +r0CodaxWkHS4oJyleW/c6RrIaQXpuvoDs3zk4E7Czp3otkYNbn5XOmeUwssfnHdK +Z05phkOTOPu220+DkdRgfks+KzgHVZhepA== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFuzCCA6OgAwIBAgIIVwoRl0LE48wwDQYJKoZIhvcNAQELBQAwazELMAkGA1UE +BhMCSVQxDjAMBgNVBAcMBU1pbGFuMSMwIQYDVQQKDBpBY3RhbGlzIFMucC5BLi8w +MzM1ODUyMDk2NzEnMCUGA1UEAwweQWN0YWxpcyBBdXRoZW50aWNhdGlvbiBSb290 +IENBMB4XDTExMDkyMjExMjIwMloXDTMwMDkyMjExMjIwMlowazELMAkGA1UEBhMC +SVQxDjAMBgNVBAcMBU1pbGFuMSMwIQYDVQQKDBpBY3RhbGlzIFMucC5BLi8wMzM1 +ODUyMDk2NzEnMCUGA1UEAwweQWN0YWxpcyBBdXRoZW50aWNhdGlvbiBSb290IENB +MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAp8bEpSmkLO/lGMWwUKNv +UTufClrJwkg4CsIcoBh/kbWHuUA/3R1oHwiD1S0eiKD4j1aPbZkCkpAW1V8IbInX +4ay8IMKx4INRimlNAJZaby/ARH6jDuSRzVju3PvHHkVH3Se5CAGfpiEd9UEtL0z9 +KK3giq0itFZljoZUj5NDKd45RnijMCO6zfB9E1fAXdKDa0hMxKufgFpbOr3JpyI/ +gCczWw63igxdBzcIy2zSekciRDXFzMwujt0q7bd9Zg1fYVEiVRvjRuPjPdA1Yprb +rxTIW6HMiRvhMCb8oJsfgadHHwTrozmSBp+Z07/T6k9QnBn+locePGX2oxgkg4YQ +51Q+qDp2JE+BIcXjDwL4k5RHILv+1A7TaLndxHqEguNTVHnd25zS8gebLra8Pu2F +be8lEfKXGkJh90qX6IuxEAf6ZYGyojnP9zz/GPvG8VqLWeICrHuS0E4UT1lF9gxe +KF+w6D9Fz8+vm2/7hNN3WpVvrJSEnu68wEqPSpP4RCHiMUVhUE4Q2OM1fEwZtN4F +v6MGn8i1zeQf1xcGDXqVdFUNaBr8EBtiZJ1t4JWgw5QHVw0U5r0F+7if5t+L4sbn +fpb2U8WANFAoWPASUHEXMLrmeGO89LKtmyuy/uE5jF66CyCU3nuDuP/jVo23Eek7 +jPKxwV2dpAtMK9myGPW1n0sCAwEAAaNjMGEwHQYDVR0OBBYEFFLYiDrIn3hm7Ynz +ezhwlMkCAjbQMA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAUUtiIOsifeGbt +ifN7OHCUyQICNtAwDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3DQEBCwUAA4ICAQAL +e3KHwGCmSUyIWOYdiPcUZEim2FgKDk8TNd81HdTtBjHIgT5q1d07GjLukD0R0i70 +jsNjLiNmsGe+b7bAEzlgqqI0JZN1Ut6nna0Oh4lScWoWPBkdg/iaKWW+9D+a2fDz +WochcYBNy+A4mz+7+uAwTc+G02UQGRjRlwKxK3JCaKygvU5a2hi/a5iB0P2avl4V +SM0RFbnAKVy06Ij3Pjaut2L9HmLecHgQHEhb2rykOLpn7VU+Xlff1ANATIGk0k9j +pwlCCRT8AKnCgHNPLsBA2RF7SOp6AsDT6ygBJlh0wcBzIm2Tlf05fbsq4/aC4yyX +X04fkZT6/iyj2HYauE2yOE+b+h1IYHkm4vP9qdCa6HCPSXrW5b0KDtst842/6+Ok +fcvHlXHo2qN8xcL4dJIEG4aspCJTQLas/kx2z/uUMsA1n3Y/buWQbqCmJqK4LL7R +K4X9p2jIugErsWx0Hbhzlefut8cl8ABMALJ+tguLHPPAUJ4lueAI3jZm/zel0btU +ZCzJJ7VLkn5l/9Mt4blOvH+kQSGQQXemOR/qnuOf0GZvBeyqdn6/axag67XH/JJU +LysRJyU3eExRarDzzFhdFPFqSBX/wge2sY0PjlxQRrM9vwGYT7JZVEc+NHt4bVaT +LnPqZih4zR0Uv6CPLy64Lo7yFIrM6bV8+2ydDKXhlg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIENjCCAx6gAwIBAgIBATANBgkqhkiG9w0BAQUFADBvMQswCQYDVQQGEwJTRTEU +MBIGA1UEChMLQWRkVHJ1c3QgQUIxJjAkBgNVBAsTHUFkZFRydXN0IEV4dGVybmFs +IFRUUCBOZXR3b3JrMSIwIAYDVQQDExlBZGRUcnVzdCBFeHRlcm5hbCBDQSBSb290 +MB4XDTAwMDUzMDEwNDgzOFoXDTIwMDUzMDEwNDgzOFowbzELMAkGA1UEBhMCU0Ux +FDASBgNVBAoTC0FkZFRydXN0IEFCMSYwJAYDVQQLEx1BZGRUcnVzdCBFeHRlcm5h +bCBUVFAgTmV0d29yazEiMCAGA1UEAxMZQWRkVHJ1c3QgRXh0ZXJuYWwgQ0EgUm9v +dDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALf3GjPm8gAELTngTlvt +H7xsD821+iO2zt6bETOXpClMfZOfvUq8k+0DGuOPz+VtUFrWlymUWoCwSXrbLpX9 +uMq/NzgtHj6RQa1wVsfwTz/oMp50ysiQVOnGXw94nZpAPA6sYapeFI+eh6FqUNzX +mk6vBbOmcZSccbNQYArHE504B4YCqOmoaSYYkKtMsE8jqzpPhNjfzp/haW+710LX +a0Tkx63ubUFfclpxCDezeWWkWaCUN/cALw3CknLa0Dhy2xSoRcRdKn23tNbE7qzN +E0S3ySvdQwAl+mG5aWpYIxG3pzOPVnVZ9c0p10a3CitlttNCbxWyuHv77+ldU9U0 +WicCAwEAAaOB3DCB2TAdBgNVHQ4EFgQUrb2YejS0Jvf6xCZU7wO94CTLVBowCwYD +VR0PBAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wgZkGA1UdIwSBkTCBjoAUrb2YejS0 +Jvf6xCZU7wO94CTLVBqhc6RxMG8xCzAJBgNVBAYTAlNFMRQwEgYDVQQKEwtBZGRU +cnVzdCBBQjEmMCQGA1UECxMdQWRkVHJ1c3QgRXh0ZXJuYWwgVFRQIE5ldHdvcmsx +IjAgBgNVBAMTGUFkZFRydXN0IEV4dGVybmFsIENBIFJvb3SCAQEwDQYJKoZIhvcN +AQEFBQADggEBALCb4IUlwtYj4g+WBpKdQZic2YR5gdkeWxQHIzZlj7DYd7usQWxH +YINRsPkyPef89iYTx4AWpb9a/IfPeHmJIZriTAcKhjW88t5RxNKWt9x+Tu5w/Rw5 +6wwCURQtjr0W4MHfRnXnJK3s9EK0hZNwEGe6nQY1ShjTK3rMUUKhemPR5ruhxSvC +Nr4TDea9Y355e6cJDUCrat2PisP29owaQgVR1EX1n6diIWgVIEM8med8vSTYqZEX +c4g/VhsxOBi0cQ+azcgOno4uG+GMmIPLHzHxREzGBHNJdmAPx/i9F4BrLunMTA5a +mnkPIAou1Z5jJh5VkpTYghdae9C8x49OhgQ= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEGDCCAwCgAwIBAgIBATANBgkqhkiG9w0BAQUFADBlMQswCQYDVQQGEwJTRTEU +MBIGA1UEChMLQWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFkZFRydXN0IFRUUCBOZXR3 +b3JrMSEwHwYDVQQDExhBZGRUcnVzdCBDbGFzcyAxIENBIFJvb3QwHhcNMDAwNTMw +MTAzODMxWhcNMjAwNTMwMTAzODMxWjBlMQswCQYDVQQGEwJTRTEUMBIGA1UEChML +QWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFkZFRydXN0IFRUUCBOZXR3b3JrMSEwHwYD +VQQDExhBZGRUcnVzdCBDbGFzcyAxIENBIFJvb3QwggEiMA0GCSqGSIb3DQEBAQUA +A4IBDwAwggEKAoIBAQCWltQhSWDia+hBBwzexODcEyPNwTXH+9ZOEQpnXvUGW2ul +CDtbKRY654eyNAbFvAWlA3yCyykQruGIgb3WntP+LVbBFc7jJp0VLhD7Bo8wBN6n +tGO0/7Gcrjyvd7ZWxbWroulpOj0OM3kyP3CCkplhbY0wCI9xP6ZIVxn4JdxLZlyl +dI+Yrsj5wAYi56xz36Uu+1LcsRVlIPo1Zmne3yzxbrww2ywkEtvrNTVokMsAsJch +PXQhI2U0K7t4WaPW4XY5mqRJjox0r26kmqPZm9I4XJuiGMx1I4S+6+JNM3GOGvDC ++Mcdoq0Dlyz4zyXG9rgkMbFjXZJ/Y/AlyVMuH79NAgMBAAGjgdIwgc8wHQYDVR0O +BBYEFJWxtPCUtr3H2tERCSG+wa9J/RB7MAsGA1UdDwQEAwIBBjAPBgNVHRMBAf8E +BTADAQH/MIGPBgNVHSMEgYcwgYSAFJWxtPCUtr3H2tERCSG+wa9J/RB7oWmkZzBl +MQswCQYDVQQGEwJTRTEUMBIGA1UEChMLQWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFk +ZFRydXN0IFRUUCBOZXR3b3JrMSEwHwYDVQQDExhBZGRUcnVzdCBDbGFzcyAxIENB +IFJvb3SCAQEwDQYJKoZIhvcNAQEFBQADggEBACxtZBsfzQ3duQH6lmM0MkhHma6X +7f1yFqZzR1r0693p9db7RcwpiURdv0Y5PejuvE1Uhh4dbOMXJ0PhiVYrqW9yTkkz +43J8KiOavD7/KCrto/8cI7pDVwlnTUtiBi34/2ydYB7YHEt9tTEv2dB8Xfjea4MY +eDdXL+gzB2ffHsdrKpV2ro9Xo/D0UrSpUwjP4E/TelOL/bscVjby/rK25Xa71SJl +pz/+0WatC7xrmYbvP33zGDLKe8bjq2RGlfgmadlVg3sslgf/WSxEo8bl6ancoWOA +WiFeIc9TVPC6b4nbqKqVz4vjccweGyBECMB6tkD9xOQ14R0WHNC8K47Wcdk= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEFTCCAv2gAwIBAgIBATANBgkqhkiG9w0BAQUFADBkMQswCQYDVQQGEwJTRTEU +MBIGA1UEChMLQWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFkZFRydXN0IFRUUCBOZXR3 +b3JrMSAwHgYDVQQDExdBZGRUcnVzdCBQdWJsaWMgQ0EgUm9vdDAeFw0wMDA1MzAx +MDQxNTBaFw0yMDA1MzAxMDQxNTBaMGQxCzAJBgNVBAYTAlNFMRQwEgYDVQQKEwtB +ZGRUcnVzdCBBQjEdMBsGA1UECxMUQWRkVHJ1c3QgVFRQIE5ldHdvcmsxIDAeBgNV +BAMTF0FkZFRydXN0IFB1YmxpYyBDQSBSb290MIIBIjANBgkqhkiG9w0BAQEFAAOC +AQ8AMIIBCgKCAQEA6Rowj4OIFMEg2Dybjxt+A3S72mnTRqX4jsIMEZBRpS9mVEBV +6tsfSlbunyNu9DnLoblv8n75XYcmYZ4c+OLspoH4IcUkzBEMP9smcnrHAZcHF/nX +GCwwfQ56HmIexkvA/X1id9NEHif2P0tEs7c42TkfYNVRknMDtABp4/MUTu7R3AnP +dzRGULD4EfL+OHn3Bzn+UZKXC1sIXzSGAa2Il+tmzV7R/9x98oTaunet3IAIx6eH +1lWfl2royBFkuucZKT8Rs3iQhCBSWxHveNCD9tVIkNAwHM+A+WD+eeSI8t0A65RF +62WUaUC6wNW0uLp9BBGo6zEFlpROWCGOn9Bg/QIDAQABo4HRMIHOMB0GA1UdDgQW +BBSBPjfYkrAfd59ctKtzquf2NGAv+jALBgNVHQ8EBAMCAQYwDwYDVR0TAQH/BAUw +AwEB/zCBjgYDVR0jBIGGMIGDgBSBPjfYkrAfd59ctKtzquf2NGAv+qFopGYwZDEL +MAkGA1UEBhMCU0UxFDASBgNVBAoTC0FkZFRydXN0IEFCMR0wGwYDVQQLExRBZGRU +cnVzdCBUVFAgTmV0d29yazEgMB4GA1UEAxMXQWRkVHJ1c3QgUHVibGljIENBIFJv +b3SCAQEwDQYJKoZIhvcNAQEFBQADggEBAAP3FUr4JNojVhaTdt02KLmuG7jD8WS6 +IBh4lSknVwW8fCr0uVFV2ocC3g8WFzH4qnkuCRO7r7IgGRLlk/lL+YPoRNWyQSW/ +iHVv/xD8SlTQX/D67zZzfRs2RcYhbbQVuE7PnFylPVoAjgbjPGsye/Kf8Lb93/Ao +GEjwxrzQvzSAlsJKsW2Ox5BF3i9nrEUEo3rcVZLJR2bYGozH7ZxOmuASu7VqTITh +4SINhwBk/ox9Yjllpu9CtoAlEmEBqCQTcAARJl/6NVDFSMwGR+gn2HCNX2TmoUQm +XiLsks3/QppEIW1cxeMiHV9HEufOX1362KqxMy3ZdvJOOjMMK7MtkAY= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEHjCCAwagAwIBAgIBATANBgkqhkiG9w0BAQUFADBnMQswCQYDVQQGEwJTRTEU +MBIGA1UEChMLQWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFkZFRydXN0IFRUUCBOZXR3 +b3JrMSMwIQYDVQQDExpBZGRUcnVzdCBRdWFsaWZpZWQgQ0EgUm9vdDAeFw0wMDA1 +MzAxMDQ0NTBaFw0yMDA1MzAxMDQ0NTBaMGcxCzAJBgNVBAYTAlNFMRQwEgYDVQQK +EwtBZGRUcnVzdCBBQjEdMBsGA1UECxMUQWRkVHJ1c3QgVFRQIE5ldHdvcmsxIzAh +BgNVBAMTGkFkZFRydXN0IFF1YWxpZmllZCBDQSBSb290MIIBIjANBgkqhkiG9w0B +AQEFAAOCAQ8AMIIBCgKCAQEA5B6a/twJWoekn0e+EV+vhDTbYjx5eLfpMLXsDBwq +xBb/4Oxx64r1EW7tTw2R0hIYLUkVAcKkIhPHEWT/IhKauY5cLwjPcWqzZwFZ8V1G +87B4pfYOQnrjfxvM0PC3KP0q6p6zsLkEqv32x7SxuCqg+1jxGaBvcCV+PmlKfw8i +2O+tCBGaKZnhqkRFmhJePp1tUvznoD1oL/BLcHwTOK28FSXx1s6rosAx1i+f4P8U +WfyEk9mHfExUE+uf0S0R+Bg6Ot4l2ffTQO2kBhLEO+GRwVY18BTcZTYJbqukB8c1 +0cIDMzZbdSZtQvESa0NvS3GU+jQd7RNuyoB/mC9suWXY6QIDAQABo4HUMIHRMB0G +A1UdDgQWBBQ5lYtii1zJ1IC6WA+XPxUIQ8yYpzALBgNVHQ8EBAMCAQYwDwYDVR0T +AQH/BAUwAwEB/zCBkQYDVR0jBIGJMIGGgBQ5lYtii1zJ1IC6WA+XPxUIQ8yYp6Fr +pGkwZzELMAkGA1UEBhMCU0UxFDASBgNVBAoTC0FkZFRydXN0IEFCMR0wGwYDVQQL +ExRBZGRUcnVzdCBUVFAgTmV0d29yazEjMCEGA1UEAxMaQWRkVHJ1c3QgUXVhbGlm +aWVkIENBIFJvb3SCAQEwDQYJKoZIhvcNAQEFBQADggEBABmrder4i2VhlRO6aQTv +hsoToMeqT2QbPxj2qC0sVY8FtzDqQmodwCVRLae/DLPt7wh/bDxGGuoYQ992zPlm +hpwsaPXpF/gxsxjE1kh9I0xowX67ARRvxdlu3rsEQmr49lx95dr6h+sNNVJn0J6X +dgWTP5XHAeZpVTh/EGGZyeNfpso+gmNIquIISD6q8rKFYqa0p9m9N5xotS1WfbC3 +P6CxB9bpT9zeRXEwMn8bLgn5v1Kh7sKAPgZcLlVAwRv1cEWw3F369nJad9Jjzc9Y +iQBCYz95OdBEsIJuQRno3eDBiFrRHnGTHyQwdOUeqN48Jzd/g66ed8/wMLH/S5no +xqE= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDTDCCAjSgAwIBAgIId3cGJyapsXwwDQYJKoZIhvcNAQELBQAwRDELMAkGA1UE +BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZpcm1UcnVz +dCBDb21tZXJjaWFsMB4XDTEwMDEyOTE0MDYwNloXDTMwMTIzMTE0MDYwNlowRDEL +MAkGA1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZp +cm1UcnVzdCBDb21tZXJjaWFsMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEA9htPZwcroRX1BiLLHwGy43NFBkRJLLtJJRTWzsO3qyxPxkEylFf6EqdbDuKP +Hx6GGaeqtS25Xw2Kwq+FNXkyLbscYjfysVtKPcrNcV/pQr6U6Mje+SJIZMblq8Yr +ba0F8PrVC8+a5fBQpIs7R6UjW3p6+DM/uO+Zl+MgwdYoic+U+7lF7eNAFxHUdPAL +MeIrJmqbTFeurCA+ukV6BfO9m2kVrn1OIGPENXY6BwLJN/3HR+7o8XYdcxXyl6S1 +yHp52UKqK39c/s4mT6NmgTWvRLpUHhwwMmWd5jyTXlBOeuM61G7MGvv50jeuJCqr +VwMiKA1JdX+3KNp1v47j3A55MQIDAQABo0IwQDAdBgNVHQ4EFgQUnZPGU4teyq8/ +nx4P5ZmVvCT2lI8wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwDQYJ +KoZIhvcNAQELBQADggEBAFis9AQOzcAN/wr91LoWXym9e2iZWEnStB03TX8nfUYG +XUPGhi4+c7ImfU+TqbbEKpqrIZcUsd6M06uJFdhrJNTxFq7YpFzUf1GO7RgBsZNj +vbz4YYCanrHOQnDiqX0GJX0nof5v7LMeJNrjS1UaADs1tDvZ110w/YETifLCBivt +Z8SOyUOyXGsViQK8YvxO8rUzqrJv0wqiUOP2O+guRMLbZjipM1ZI8W0bM40NjD9g +N53Tym1+NH4Nn3J2ixufcv1SNUFFApYvHLKac0khsUlHRUe072o0EclNmsxZt9YC +nlpOZbWUrhvfKbAW8b8Angc6F2S1BLUjIZkKlTuXfO8= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDTDCCAjSgAwIBAgIIfE8EORzUmS0wDQYJKoZIhvcNAQEFBQAwRDELMAkGA1UE +BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZpcm1UcnVz +dCBOZXR3b3JraW5nMB4XDTEwMDEyOTE0MDgyNFoXDTMwMTIzMTE0MDgyNFowRDEL +MAkGA1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZp +cm1UcnVzdCBOZXR3b3JraW5nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEAtITMMxcua5Rsa2FSoOujz3mUTOWUgJnLVWREZY9nZOIG41w3SfYvm4SEHi3y +YJ0wTsyEheIszx6e/jarM3c1RNg1lho9Nuh6DtjVR6FqaYvZ/Ls6rnla1fTWcbua +kCNrmreIdIcMHl+5ni36q1Mr3Lt2PpNMCAiMHqIjHNRqrSK6mQEubWXLviRmVSRL +QESxG9fhwoXA3hA/Pe24/PHxI1Pcv2WXb9n5QHGNfb2V1M6+oF4nI979ptAmDgAp +6zxG8D1gvz9Q0twmQVGeFDdCBKNwV6gbh+0t+nvujArjqWaJGctB+d1ENmHP4ndG +yH329JKBNv3bNPFyfvMMFr20FQIDAQABo0IwQDAdBgNVHQ4EFgQUBx/S55zawm6i +QLSwelAQUHTEyL0wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwDQYJ +KoZIhvcNAQEFBQADggEBAIlXshZ6qML91tmbmzTCnLQyFE2npN/svqe++EPbkTfO +tDIuUFUaNU52Q3Eg75N3ThVwLofDwR1t3Mu1J9QsVtFSUzpE0nPIxBsFZVpikpzu +QY0x2+c06lkh1QF612S4ZDnNye2v7UsDSKegmQGA3GWjNq5lWUhPgkvIZfFXHeVZ +Lgo/bNjR9eUJtGxUAArgFU2HdW23WJZa3W3SAKD0m0i+wzekujbgfIeFlxoVot4u +olu9rxj5kFDNcFn4J2dHy8egBzp90SxdbBk6ZrV9/ZFvgrG+CJPbFEfxojfHRZ48 +x3evZKiT3/Zpg4Jg8klCNO1aAFSFHBY2kgxc+qatv9s= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFRjCCAy6gAwIBAgIIbYwURrGmCu4wDQYJKoZIhvcNAQEMBQAwQTELMAkGA1UE +BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MRwwGgYDVQQDDBNBZmZpcm1UcnVz +dCBQcmVtaXVtMB4XDTEwMDEyOTE0MTAzNloXDTQwMTIzMTE0MTAzNlowQTELMAkG +A1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MRwwGgYDVQQDDBNBZmZpcm1U +cnVzdCBQcmVtaXVtMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAxBLf +qV/+Qd3d9Z+K4/as4Tx4mrzY8H96oDMq3I0gW64tb+eT2TZwamjPjlGjhVtnBKAQ +JG9dKILBl1fYSCkTtuG+kU3fhQxTGJoeJKJPj/CihQvL9Cl/0qRY7iZNyaqoe5rZ ++jjeRFcV5fiMyNlI4g0WJx0eyIOFJbe6qlVBzAMiSy2RjYvmia9mx+n/K+k8rNrS +s8PhaJyJ+HoAVt70VZVs+7pk3WKL3wt3MutizCaam7uqYoNMtAZ6MMgpv+0GTZe5 +HMQxK9VfvFMSF5yZVylmd2EhMQcuJUmdGPLu8ytxjLW6OQdJd/zvLpKQBY0tL3d7 +70O/Nbua2Plzpyzy0FfuKE4mX4+QaAkvuPjcBukumj5Rp9EixAqnOEhss/n/fauG +V+O61oV4d7pD6kh/9ti+I20ev9E2bFhc8e6kGVQa9QPSdubhjL08s9NIS+LI+H+S +qHZGnEJlPqQewQcDWkYtuJfzt9WyVSHvutxMAJf7FJUnM7/oQ0dG0giZFmA7mn7S +5u046uwBHjxIVkkJx0w3AJ6IDsBz4W9m6XJHMD4Q5QsDyZpCAGzFlH5hxIrff4Ia +C1nEWTJ3s7xgaVY5/bQGeyzWZDbZvUjthB9+pSKPKrhC9IK31FOQeE4tGv2Bb0TX +OwF0lkLgAOIua+rF7nKsu7/+6qqo+Nz2snmKtmcCAwEAAaNCMEAwHQYDVR0OBBYE +FJ3AZ6YMItkm9UWrpmVSESfYRaxjMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/ +BAQDAgEGMA0GCSqGSIb3DQEBDAUAA4ICAQCzV00QYk465KzquByvMiPIs0laUZx2 +KI15qldGF9X1Uva3ROgIRL8YhNILgM3FEv0AVQVhh0HctSSePMTYyPtwni94loMg +Nt58D2kTiKV1NpgIpsbfrM7jWNa3Pt668+s0QNiigfV4Py/VpfzZotReBA4Xrf5B +8OWycvpEgjNC6C1Y91aMYj+6QrCcDFx+LmUmXFNPALJ4fqENmS2NuB2OosSw/WDQ +MKSOyARiqcTtNd56l+0OOF6SL5Nwpamcb6d9Ex1+xghIsV5n61EIJenmJWtSKZGc +0jlzCFfemQa0W50QBuHCAKi4HEoCChTQwUHK+4w1IX2COPKpVJEZNZOUbWo6xbLQ +u4mGk+ibyQ86p3q4ofB4Rvr8Ny/lioTz3/4E2aFooC8k4gmVBtWVyuEklut89pMF +u+1z6S3RdTnX5yTb2E5fQ4+e0BQ5v1VwSJlXMbSc7kqYA5YwH2AG7hsj/oFgIxpH +YoWlzBk0gG+zrBrjn/B7SK3VAdlntqlyk+otZrWyuOQ9PLLvTIzq6we/qzWaVYa8 +GKa1qF60g2xraUDTn9zxw2lrueFtCfTxqlB2Cnp9ehehVZZCmTEJ3WARjQUwfuaO +RtGdFNrHF+QFlozEJLUbzxQHskD4o55BhrwE0GuWyCqANP2/7waj3VjFhT0+j/6e +KeC2uAloGRwYQw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIB/jCCAYWgAwIBAgIIdJclisc/elQwCgYIKoZIzj0EAwMwRTELMAkGA1UEBhMC +VVMxFDASBgNVBAoMC0FmZmlybVRydXN0MSAwHgYDVQQDDBdBZmZpcm1UcnVzdCBQ +cmVtaXVtIEVDQzAeFw0xMDAxMjkxNDIwMjRaFw00MDEyMzExNDIwMjRaMEUxCzAJ +BgNVBAYTAlVTMRQwEgYDVQQKDAtBZmZpcm1UcnVzdDEgMB4GA1UEAwwXQWZmaXJt +VHJ1c3QgUHJlbWl1bSBFQ0MwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQNMF4bFZ0D +0KF5Nbc6PJJ6yhUczWLznCZcBz3lVPqj1swS6vQUX+iOGasvLkjmrBhDeKzQN8O9 +ss0s5kfiGuZjuD0uL3jET9v0D6RoTFVya5UdThhClXjMNzyR4ptlKymjQjBAMB0G +A1UdDgQWBBSaryl6wBE1NSZRMADDav5A1a7WPDAPBgNVHRMBAf8EBTADAQH/MA4G +A1UdDwEB/wQEAwIBBjAKBggqhkjOPQQDAwNnADBkAjAXCfOHiFBar8jAQr9HX/Vs +aobgxCd05DhT1wV/GzTjxi+zygk8N53X57hG8f2h4nECMEJZh0PUUd+60wkyWs6I +flc9nF9Ca/UHLbXwgpP5WW+uZPpY5Yse42O+tYHNbwKMeQ== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDoDCCAoigAwIBAgIBMTANBgkqhkiG9w0BAQUFADBDMQswCQYDVQQGEwJKUDEc +MBoGA1UEChMTSmFwYW5lc2UgR292ZXJubWVudDEWMBQGA1UECxMNQXBwbGljYXRp +b25DQTAeFw0wNzEyMTIxNTAwMDBaFw0xNzEyMTIxNTAwMDBaMEMxCzAJBgNVBAYT +AkpQMRwwGgYDVQQKExNKYXBhbmVzZSBHb3Zlcm5tZW50MRYwFAYDVQQLEw1BcHBs +aWNhdGlvbkNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAp23gdE6H +j6UG3mii24aZS2QNcfAKBZuOquHMLtJqO8F6tJdhjYq+xpqcBrSGUeQ3DnR4fl+K +f5Sk10cI/VBaVuRorChzoHvpfxiSQE8tnfWuREhzNgaeZCw7NCPbXCbkcXmP1G55 +IrmTwcrNwVbtiGrXoDkhBFcsovW8R0FPXjQilbUfKW1eSvNNcr5BViCH/OlQR9cw +FO5cjFW6WY2H/CPek9AEjP3vbb3QesmlOmpyM8ZKDQUXKi17safY1vC+9D/qDiht +QWEjdnjDuGWk81quzMKq2edY3rZ+nYVunyoKb58DKTCXKB28t89UKU5RMfkntigm +/qJj5kEW8DOYRwIDAQABo4GeMIGbMB0GA1UdDgQWBBRUWssmP3HMlEYNllPqa0jQ +k/5CdTAOBgNVHQ8BAf8EBAMCAQYwWQYDVR0RBFIwUKROMEwxCzAJBgNVBAYTAkpQ +MRgwFgYDVQQKDA/ml6XmnKzlm73mlL/lupwxIzAhBgNVBAsMGuOCouODl+ODquOC +seODvOOCt+ODp+ODs0NBMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEFBQAD +ggEBADlqRHZ3ODrso2dGD/mLBqj7apAxzn7s2tGJfHrrLgy9mTLnsCTWw//1sogJ +hyzjVOGjprIIC8CFqMjSnHH2HZ9g/DgzE+Ge3Atf2hZQKXsvcJEPmbo0NI2VdMV+ +eKlmXb3KIXdCEKxmJj3ekav9FfBv7WxfEPjzFvYDio+nEhEMy/0/ecGc/WLuo89U +DNErXxc+4z6/wCs+CZv+iKZ+tJIX/COUgb1up8WMwusRRdv4QcmWdupwX3kSa+Sj +B1oF7ydJzyGfikwJcGapJsErEU4z0g781mzSDjJkaP+tBXhfAx2o45CsJOAPQKdL +rosot4LKGAfmt1t06SAZf7IbiVQ= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDdzCCAl+gAwIBAgIIXDPLYixfszIwDQYJKoZIhvcNAQELBQAwPDEeMBwGA1UE +AwwVQXRvcyBUcnVzdGVkUm9vdCAyMDExMQ0wCwYDVQQKDARBdG9zMQswCQYDVQQG +EwJERTAeFw0xMTA3MDcxNDU4MzBaFw0zMDEyMzEyMzU5NTlaMDwxHjAcBgNVBAMM +FUF0b3MgVHJ1c3RlZFJvb3QgMjAxMTENMAsGA1UECgwEQXRvczELMAkGA1UEBhMC +REUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCVhTuXbyo7LjvPpvMp +Nb7PGKw+qtn4TaA+Gke5vJrf8v7MPkfoepbCJI419KkM/IL9bcFyYie96mvr54rM +VD6QUM+A1JX76LWC1BTFtqlVJVfbsVD2sGBkWXppzwO3bw2+yj5vdHLqqjAqc2K+ +SZFhyBH+DgMq92og3AIVDV4VavzjgsG1xZ1kCWyjWZgHJ8cblithdHFsQ/H3NYkQ +4J7sVaE3IqKHBAUsR320HLliKWYoyrfhk/WklAOZuXCFteZI6o1Q/NnezG8HDt0L +cp2AMBYHlT8oDv3FdU9T1nSatCQujgKRz3bFmx5VdJx4IbHwLfELn8LVlhgf8FQi +eowHAgMBAAGjfTB7MB0GA1UdDgQWBBSnpQaxLKYJYO7Rl+lwrrw7GWzbITAPBgNV +HRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFKelBrEspglg7tGX6XCuvDsZbNshMBgG +A1UdIAQRMA8wDQYLKwYBBAGwLQMEAQEwDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3 +DQEBCwUAA4IBAQAmdzTblEiGKkGdLD4GkGDEjKwLVLgfuXvTBznk+j57sj1O7Z8j +vZfza1zv7v1Apt+hk6EKhqzvINB5Ab149xnYJDE0BAGmuhWawyfc2E8PzBhj/5kP +DpFrdRbhIfzYJsdHt6bPWHJxfrrhTZVHO8mvbaG0weyJ9rQPOLXiZNwlz6bb65pc +maHFCN795trV1lpFDMS3wrUU77QR/w4VtfX128a961qn8FYiqTxlVMYVqL2Gns2D +lmh6cYGJ4Qvh6hEbaAjMaZ7snkGeRDImeuKHCnE96+RapNLbxc3G3mB/ufNPRJLv +KrcYPqcZ2Qt9sTdBQrC6YB3y/gkRsPCHe6ed +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIGFDCCA/ygAwIBAgIIU+w77vuySF8wDQYJKoZIhvcNAQEFBQAwUTELMAkGA1UE +BhMCRVMxQjBABgNVBAMMOUF1dG9yaWRhZCBkZSBDZXJ0aWZpY2FjaW9uIEZpcm1h +cHJvZmVzaW9uYWwgQ0lGIEE2MjYzNDA2ODAeFw0wOTA1MjAwODM4MTVaFw0zMDEy +MzEwODM4MTVaMFExCzAJBgNVBAYTAkVTMUIwQAYDVQQDDDlBdXRvcmlkYWQgZGUg +Q2VydGlmaWNhY2lvbiBGaXJtYXByb2Zlc2lvbmFsIENJRiBBNjI2MzQwNjgwggIi +MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDKlmuO6vj78aI14H9M2uDDUtd9 +thDIAl6zQyrET2qyyhxdKJp4ERppWVevtSBC5IsP5t9bpgOSL/UR5GLXMnE42QQM +cas9UX4PB99jBVzpv5RvwSmCwLTaUbDBPLutN0pcyvFLNg4kq7/DhHf9qFD0sefG +L9ItWY16Ck6WaVICqjaY7Pz6FIMMNx/Jkjd/14Et5cS54D40/mf0PmbR0/RAz15i +NA9wBj4gGFrO93IbJWyTdBSTo3OxDqqHECNZXyAFGUftaI6SEspd/NYrspI8IM/h +X68gvqB2f3bl7BqGYTM+53u0P6APjqK5am+5hyZvQWyIplD9amML9ZMWGxmPsu2b +m8mQ9QEM3xk9Dz44I8kvjwzRAv4bVdZO0I08r0+k8/6vKtMFnXkIoctXMbScyJCy +Z/QYFpM6/EfY0XiWMR+6KwxfXZmtY4laJCB22N/9q06mIqqdXuYnin1oKaPnirja +EbsXLZmdEyRG98Xi2J+Of8ePdG1asuhy9azuJBCtLxTa/y2aRnFHvkLfuwHb9H/T +KI8xWVvTyQKmtFLKbpf7Q8UIJm+K9Lv9nyiqDdVF8xM6HdjAeI9BZzwelGSuewvF +6NkBiDkal4ZkQdU7hwxu+g/GvUgUvzlN1J5Bto+WHWOWk9mVBngxaJ43BjuAiUVh +OSPHG0SjFeUc+JIwuwIDAQABo4HvMIHsMBIGA1UdEwEB/wQIMAYBAf8CAQEwDgYD +VR0PAQH/BAQDAgEGMB0GA1UdDgQWBBRlzeurNR4APn7VdMActHNHDhpkLzCBpgYD +VR0gBIGeMIGbMIGYBgRVHSAAMIGPMC8GCCsGAQUFBwIBFiNodHRwOi8vd3d3LmZp +cm1hcHJvZmVzaW9uYWwuY29tL2NwczBcBggrBgEFBQcCAjBQHk4AUABhAHMAZQBv +ACAAZABlACAAbABhACAAQgBvAG4AYQBuAG8AdgBhACAANAA3ACAAQgBhAHIAYwBl +AGwAbwBuAGEAIAAwADgAMAAxADcwDQYJKoZIhvcNAQEFBQADggIBABd9oPm03cXF +661LJLWhAqvdpYhKsg9VSytXjDvlMd3+xDLx51tkljYyGOylMnfX40S2wBEqgLk9 +am58m9Ot/MPWo+ZkKXzR4Tgegiv/J2Wv+xYVxC5xhOW1//qkR71kMrv2JYSiJ0L1 +ILDCExARzRAVukKQKtJE4ZYm6zFIEv0q2skGz3QeqUvVhyj5eTSSPi5E6PaPT481 +PyWzOdxjKpBrIF/EUhJOlywqrJ2X3kjyo2bbwtKDlaZmp54lD+kLM5FlClrD2VQS +3a/DTg4fJl4N3LON7NWBcN7STyQF82xO9UxJZo3R/9ILJUFI/lGExkKvgATP0H5k +SeTy36LssUzAKh3ntLFlosS88Zj0qnAHY7S42jtM+kAiMFsRpvAFDsYCA0irhpuF +3dvd6qJ2gHN99ZwExEWN57kci57q13XRcrHedUTnQn3iV2t93Jm8PYMo6oCTjcVM +ZcFwgbg4/EMxsvYDNEeyrPsiBsse3RdHHF9mudMaotoRsaS8I8nkvof/uZS2+F0g +StRf571oe2XyFR7SOqkt6dhrJKyXWERHrVkY8SFlcN7ONGCoQPHzPKTDKCOM/icz +Q0CgFzzr6juwcqajuUpLXhZI9LK8yIySxZ2frHI2vDSANGupi5LAuBft7HZT9SQB +jLMi6Et8Vcad+qMUu2WFbm5PEn4KPJ2V +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDdzCCAl+gAwIBAgIEAgAAuTANBgkqhkiG9w0BAQUFADBaMQswCQYDVQQGEwJJ +RTESMBAGA1UEChMJQmFsdGltb3JlMRMwEQYDVQQLEwpDeWJlclRydXN0MSIwIAYD +VQQDExlCYWx0aW1vcmUgQ3liZXJUcnVzdCBSb290MB4XDTAwMDUxMjE4NDYwMFoX +DTI1MDUxMjIzNTkwMFowWjELMAkGA1UEBhMCSUUxEjAQBgNVBAoTCUJhbHRpbW9y +ZTETMBEGA1UECxMKQ3liZXJUcnVzdDEiMCAGA1UEAxMZQmFsdGltb3JlIEN5YmVy +VHJ1c3QgUm9vdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKMEuyKr +mD1X6CZymrV51Cni4eiVgLGw41uOKymaZN+hXe2wCQVt2yguzmKiYv60iNoS6zjr +IZ3AQSsBUnuId9Mcj8e6uYi1agnnc+gRQKfRzMpijS3ljwumUNKoUMMo6vWrJYeK +mpYcqWe4PwzV9/lSEy/CG9VwcPCPwBLKBsua4dnKM3p31vjsufFoREJIE9LAwqSu +XmD+tqYF/LTdB1kC1FkYmGP1pWPgkAx9XbIGevOF6uvUA65ehD5f/xXtabz5OTZy +dc93Uk3zyZAsuT3lySNTPx8kmCFcB5kpvcY67Oduhjprl3RjM71oGDHweI12v/ye +jl0qhqdNkNwnGjkCAwEAAaNFMEMwHQYDVR0OBBYEFOWdWTCCR1jMrPoIVDaGezq1 +BE3wMBIGA1UdEwEB/wQIMAYBAf8CAQMwDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3 +DQEBBQUAA4IBAQCFDF2O5G9RaEIFoN27TyclhAO992T9Ldcw46QQF+vaKSm2eT92 +9hkTI7gQCvlYpNRhcL0EYWoSihfVCr3FvDB81ukMJY2GQE/szKN+OMY3EU/t3Wgx +jkzSswF07r51XgdIGn9w/xZchMB5hbgF/X++ZRGjD8ACtPhSNzkE1akxehi/oCr0 +Epn3o0WC4zxe9Z2etciefC7IpJ5OCBRLbf1wbWsaY71k5h+3zvDyny67G7fyUIhz +ksLi4xaNmjICq44Y3ekQEe5+NauQrz4wlHrQMz2nZQ/1/I6eYs9HRCwBXbsdtTLS +R9I4LtD+gdwyah617jzV/OeBHRnDJELqYzmp +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDUzCCAjugAwIBAgIBATANBgkqhkiG9w0BAQUFADBLMQswCQYDVQQGEwJOTzEd +MBsGA1UECgwUQnV5cGFzcyBBUy05ODMxNjMzMjcxHTAbBgNVBAMMFEJ1eXBhc3Mg +Q2xhc3MgMiBDQSAxMB4XDTA2MTAxMzEwMjUwOVoXDTE2MTAxMzEwMjUwOVowSzEL +MAkGA1UEBhMCTk8xHTAbBgNVBAoMFEJ1eXBhc3MgQVMtOTgzMTYzMzI3MR0wGwYD +VQQDDBRCdXlwYXNzIENsYXNzIDIgQ0EgMTCCASIwDQYJKoZIhvcNAQEBBQADggEP +ADCCAQoCggEBAIs8B0XY9t/mx8q6jUPFR42wWsE425KEHK8T1A9vNkYgxC7McXA0 +ojTTNy7Y3Tp3L8DrKehc0rWpkTSHIln+zNvnma+WwajHQN2lFYxuyHyXA8vmIPLX +l18xoS830r7uvqmtqEyeIWZDO6i88wmjONVZJMHCR3axiFyCO7srpgTXjAePzdVB +HfCuuCkslFJgNJQ72uA40Z0zPhX0kzLFANq1KWYOOngPIVJfAuWSeyXTkh4vFZ2B +5J2O6O+JzhRMVB0cgRJNcKi+EAUXfh/RuFdV7c27UsKwHnjCTTZoy1YmwVLBvXb3 +WNVyfh9EdrsAiR0WnVE1703CVu9r4Iw7DekCAwEAAaNCMEAwDwYDVR0TAQH/BAUw +AwEB/zAdBgNVHQ4EFgQUP42aWYv8e3uco684sDntkHGA1sgwDgYDVR0PAQH/BAQD +AgEGMA0GCSqGSIb3DQEBBQUAA4IBAQAVGn4TirnoB6NLJzKyQJHyIdFkhb5jatLP +gcIV1Xp+DCmsNx4cfHZSldq1fyOhKXdlyTKdqC5Wq2B2zha0jX94wNWZUYN/Xtm+ +DKhQ7SLHrQVMdvvt7h5HZPb3J31cKA9FxVxiXqaakZG3Uxcu3K1gnZZkOb1naLKu +BctN518fV4bVIJwo+28TOPX2EZL2fZleHwzoq0QkKXJAPTZSr4xYkHPB7GEseaHs +h7U/2k3ZIQAw3pDaDtMaSKk+hQsUi4y8QZ5q9w5wwDX3OaJdZtB7WZ+oRxKaJyOk +LY4ng5IgodcVf/EuGO70SH8vf/GhGLWhC5SgYiAynB321O+/TIho +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFWTCCA0GgAwIBAgIBAjANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJOTzEd +MBsGA1UECgwUQnV5cGFzcyBBUy05ODMxNjMzMjcxIDAeBgNVBAMMF0J1eXBhc3Mg +Q2xhc3MgMiBSb290IENBMB4XDTEwMTAyNjA4MzgwM1oXDTQwMTAyNjA4MzgwM1ow +TjELMAkGA1UEBhMCTk8xHTAbBgNVBAoMFEJ1eXBhc3MgQVMtOTgzMTYzMzI3MSAw +HgYDVQQDDBdCdXlwYXNzIENsYXNzIDIgUm9vdCBDQTCCAiIwDQYJKoZIhvcNAQEB +BQADggIPADCCAgoCggIBANfHXvfBB9R3+0Mh9PT1aeTuMgHbo4Yf5FkNuud1g1Lr +6hxhFUi7HQfKjK6w3Jad6sNgkoaCKHOcVgb/S2TwDCo3SbXlzwx87vFKu3MwZfPV +L4O2fuPn9Z6rYPnT8Z2SdIrkHJasW4DptfQxh6NR/Md+oW+OU3fUl8FVM5I+GC91 +1K2GScuVr1QGbNgGE41b/+EmGVnAJLqBcXmQRFBoJJRfuLMR8SlBYaNByyM21cHx +MlAQTn/0hpPshNOOvEu/XAFOBz3cFIqUCqTqc/sLUegTBxj6DvEr0VQVfTzh97QZ +QmdiXnfgolXsttlpF9U6r0TtSsWe5HonfOV116rLJeffawrbD02TTqigzXsu8lkB +arcNuAeBfos4GzjmCleZPe4h6KP1DBbdi+w0jpwqHAAVF41og9JwnxgIzRFo1clr +Us3ERo/ctfPYV3Me6ZQ5BL/T3jjetFPsaRyifsSP5BtwrfKi+fv3FmRmaZ9JUaLi +FRhnBkp/1Wy1TbMz4GHrXb7pmA8y1x1LPC5aAVKRCfLf6o3YBkBjqhHk/sM3nhRS +P/TizPJhk9H9Z2vXUq6/aKtAQ6BXNVN48FP4YUIHZMbXb5tMOA1jrGKvNouicwoN +9SG9dKpN6nIDSdvHXx1iY8f93ZHsM+71bbRuMGjeyNYmsHVee7QHIJihdjK4TWxP +AgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFMmAd+BikoL1Rpzz +uvdMw964o605MA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAgEAU18h +9bqwOlI5LJKwbADJ784g7wbylp7ppHR/ehb8t/W2+xUbP6umwHJdELFx7rxP462s +A20ucS6vxOOto70MEae0/0qyexAQH6dXQbLArvQsWdZHEIjzIVEpMMpghq9Gqx3t +OluwlN5E40EIosHsHdb9T7bWR9AUC8rmyrV7d35BH16Dx7aMOZawP5aBQW9gkOLo ++fsicdl9sz1Gv7SEr5AcD48Saq/v7h56rgJKihcrdv6sVIkkLE8/trKnToyokZf7 +KcZ7XC25y2a2t6hbElGFtQl+Ynhw/qlqYLYdDnkM/crqJIByw5c/8nerQyIKx+u2 +DISCLIBrQYoIwOula9+ZEsuK1V6ADJHgJgg2SMX6OBE1/yWDLfJ6v9r9jv6ly0Us +H8SIU653DtmadsWOLB2jutXsMq7Aqqz30XpN69QH4kj3Io6wpJ9qzo6ysmD0oyLQ +I+uUWnpp3Q+/QFesa1lQ2aOZ4W7+jQF5JyMV3pKdewlNWudLSDBaGOYKbeaP4NK7 +5t98biGCwWg5TbSYWGZizEqQXsP6JwSxeRV0mcy+rSDeJmAc61ZRpqPq5KM/p/9h +3PFaTWwyI0PurKju7koSCTxdccK+efrCh2gdC/1cacwG0Jp9VJkqyTkaGa9LKkPz +Y11aWOIv4x3kqdbQCtCev9eBCfHJxyYNrJgWVqA= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDUzCCAjugAwIBAgIBAjANBgkqhkiG9w0BAQUFADBLMQswCQYDVQQGEwJOTzEd +MBsGA1UECgwUQnV5cGFzcyBBUy05ODMxNjMzMjcxHTAbBgNVBAMMFEJ1eXBhc3Mg +Q2xhc3MgMyBDQSAxMB4XDTA1MDUwOTE0MTMwM1oXDTE1MDUwOTE0MTMwM1owSzEL +MAkGA1UEBhMCTk8xHTAbBgNVBAoMFEJ1eXBhc3MgQVMtOTgzMTYzMzI3MR0wGwYD +VQQDDBRCdXlwYXNzIENsYXNzIDMgQ0EgMTCCASIwDQYJKoZIhvcNAQEBBQADggEP +ADCCAQoCggEBAKSO13TZKWTeXx+HgJHqTjnmGcZEC4DVC69TB4sSveZn8AKxifZg +isRbsELRwCGoy+Gb72RRtqfPFfV0gGgEkKBYouZ0plNTVUhjP5JW3SROjvi6K//z +NIqeKNc0n6wv1g/xpC+9UrJJhW05NfBEMJNGJPO251P7vGGvqaMU+8IXF4Rs4HyI ++MkcVyzwPX6UvCWThOiaAJpFBUJXgPROztmuOfbIUxAMZTpHe2DC1vqRycZxbL2R +hzyRhkmr8w+gbCZ2Xhysm3HljbybIR6c1jh+JIAVMYKWsUnTYjdbiAwKYjT+p0h+ +mbEwi5A3lRyoH6UsjfRVyNvdWQrCrXig9IsCAwEAAaNCMEAwDwYDVR0TAQH/BAUw +AwEB/zAdBgNVHQ4EFgQUOBTmyPCppAP0Tj4io1vy1uCtQHQwDgYDVR0PAQH/BAQD +AgEGMA0GCSqGSIb3DQEBBQUAA4IBAQABZ6OMySU9E2NdFm/soT4JXJEVKirZgCFP +Bdy7pYmrEzMqnji3jG8CcmPHc3ceCQa6Oyh7pEfJYWsICCD8igWKH7y6xsL+z27s +EzNxZy5p+qksP2bAEllNC1QCkoS72xLvg3BweMhT+t/Gxv/ciC8HwEmdMldg0/L2 +mSlf56oBzKwzqBwKu5HEA6BvtjT5htOzdlSY9EqBs1OdTUDs5XcTRa9bqh/YL0yC +e/4qxFi7T/ye/QNlGioOw6UgFpRreaaiErS7GqQjel/wroQk5PMr+4okoyeYZdow +dXb8GZHo2+ubPzK/QJcHJrrM85SFSnonk8+QQtS4Wxam58tAA915 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFWTCCA0GgAwIBAgIBAjANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJOTzEd +MBsGA1UECgwUQnV5cGFzcyBBUy05ODMxNjMzMjcxIDAeBgNVBAMMF0J1eXBhc3Mg +Q2xhc3MgMyBSb290IENBMB4XDTEwMTAyNjA4Mjg1OFoXDTQwMTAyNjA4Mjg1OFow +TjELMAkGA1UEBhMCTk8xHTAbBgNVBAoMFEJ1eXBhc3MgQVMtOTgzMTYzMzI3MSAw +HgYDVQQDDBdCdXlwYXNzIENsYXNzIDMgUm9vdCBDQTCCAiIwDQYJKoZIhvcNAQEB +BQADggIPADCCAgoCggIBAKXaCpUWUOOV8l6ddjEGMnqb8RB2uACatVI2zSRHsJ8Y +ZLya9vrVediQYkwiL944PdbgqOkcLNt4EemOaFEVcsfzM4fkoF0LXOBXByow9c3E +N3coTRiR5r/VUv1xLXA+58bEiuPwKAv0dpihi4dVsjoT/Lc+JzeOIuOoTyrvYLs9 +tznDDgFHmV0ST9tD+leh7fmdvhFHJlsTmKtdFoqwNxxXnUX/iJY2v7vKB3tvh2PX +0DJq1l1sDPGzbjniazEuOQAnFN44wOwZZoYS6J1yFhNkUsepNxz9gjDthBgd9K5c +/3ATAOux9TN6S9ZV+AWNS2mw9bMoNlwUxFFzTWsL8TQH2xc519woe2v1n/MuwU8X +KhDzzMro6/1rqy6any2CbgTUUgGTLT2G/H783+9CHaZr77kgxve9oKeV/afmiSTY +zIw0bOIjL9kSGiG5VZFvC5F5GQytQIgLcOJ60g7YaEi7ghM5EFjp2CoHxhLbWNvS +O1UQRwUVZ2J+GGOmRj8JDlQyXr8NYnon74Do29lLBlo3WiXQCBJ31G8JUJc9yB3D +34xFMFbG02SrZvPAXpacw8Tvw3xrizp5f7NJzz3iiZ+gMEuFuZyUJHmPfWupRWgP +K9Dx2hzLabjKSWJtyNBjYt1gD1iqj6G8BaVmos8bdrKEZLFMOVLAMLrwjEsCsLa3 +AgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEe4zf/lb+74suwv +Tg75JbCOPGvDMA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAgEAACAj +QTUEkMJAYmDv4jVM1z+s4jSQuKFvdvoWFqRINyzpkMLyPPgKn9iB5btb2iUspKdV +cSQy9sgL8rxq+JOssgfCX5/bzMiKqr5qb+FJEMwx14C7u8jYog5kV+qi9cKpMRXS +IGrs/CIBKM+GuIAeqcwRpTzyFrNHnfzSgCHEy9BHcEGhyoMZCCxt8l13nIoUE9Q2 +HJLw5QY33KbmkJs4j1xrG0aGQ0JfPgEHU1RdZX33inOhmlRaHylDFCfChQ+1iHsa +O5S3HWCntZznKWlXWpuTekMwGwPXYshApqr8ZORK15FTAaggiG6cX0S5y2CBNOxv +033aSF/rtJC8LakcC6wc1aJoIIAE1vyxjy+7SjENSoYc6+I2KSb12tjE8nVhz36u +dmNKekBlk4f4HoCMhuWG1o8O/FMsYOgWYRqiPkN7zTlgVGr18okmAWiDSKIz6MkE +kbIRNBE+6tBDGR8Dk5AM/1E9V/RBbuHLoL7ryWPNbczk+DaqaJ3tvV2XcEQNtg41 +3OEMXbugUZTLfhbrES+jkkXITHHZvMmZUldGL1DPvTVp9D0VzgalLA8+9oG6lLvD +u79leNKGef9JOxqDDPDeeOzI8k1MGt6CKfjBWtrt7uYnXuhF0J0cUahoq0Tj0Itq +4/g7u9xN12TyUb7mqqta6THuBrxzvxNiCp/HuZc= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEDzCCAvegAwIBAgIBATANBgkqhkiG9w0BAQUFADBKMQswCQYDVQQGEwJTSzET +MBEGA1UEBxMKQnJhdGlzbGF2YTETMBEGA1UEChMKRGlzaWcgYS5zLjERMA8GA1UE +AxMIQ0EgRGlzaWcwHhcNMDYwMzIyMDEzOTM0WhcNMTYwMzIyMDEzOTM0WjBKMQsw +CQYDVQQGEwJTSzETMBEGA1UEBxMKQnJhdGlzbGF2YTETMBEGA1UEChMKRGlzaWcg +YS5zLjERMA8GA1UEAxMIQ0EgRGlzaWcwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAw +ggEKAoIBAQCS9jHBfYj9mQGp2HvycXXxMcbzdWb6UShGhJd4NLxs/LxFWYgmGErE +Nx+hSkS943EE9UQX4j/8SFhvXJ56CbpRNyIjZkMhsDxkovhqFQ4/61HhVKndBpnX +mjxUizkDPw/Fzsbrg3ICqB9x8y34dQjbYkzo+s7552oftms1grrijxaSfQUMbEYD +XcDtab86wYqg6I7ZuUUohwjstMoVvoLdtUSLLa2GDGhibYVW8qwUYzrG0ZmsNHhW +S8+2rT+MitcE5eN4TPWGqvWP+j1scaMtymfraHtuM6kMgiioTGohQBUgDCZbg8Kp +FhXAJIJdKxatymP2dACw30PEEGBWZ2NFAgMBAAGjgf8wgfwwDwYDVR0TAQH/BAUw +AwEB/zAdBgNVHQ4EFgQUjbJJaJ1yCCW5wCf1UJNWSEZx+Y8wDgYDVR0PAQH/BAQD +AgEGMDYGA1UdEQQvMC2BE2Nhb3BlcmF0b3JAZGlzaWcuc2uGFmh0dHA6Ly93d3cu +ZGlzaWcuc2svY2EwZgYDVR0fBF8wXTAtoCugKYYnaHR0cDovL3d3dy5kaXNpZy5z +ay9jYS9jcmwvY2FfZGlzaWcuY3JsMCygKqAohiZodHRwOi8vY2EuZGlzaWcuc2sv +Y2EvY3JsL2NhX2Rpc2lnLmNybDAaBgNVHSAEEzARMA8GDSuBHpGT5goAAAABAQEw +DQYJKoZIhvcNAQEFBQADggEBAF00dGFMrzvY/59tWDYcPQuBDRIrRhCA/ec8J9B6 +yKm2fnQwM6M6int0wHl5QpNt/7EpFIKrIYwvF/k/Ji/1WcbvgAa3mkkp7M5+cTxq +EEHA9tOasnxakZzArFvITV734VP/Q3f8nktnbNfzg9Gg4H8l37iYC5oyOGwwoPP/ +CBUz91BKez6jPiCp3C9WgArtQVCwyfTssuMmRAAOb54GvCKWU3BlxFAKRmukLyeB +EicTXxChds6KezfqwzlhA5WYOudsiCUI/HloDYd9Yvi0X/vF2Ey9WLw/Q1vUHgFN +PGO+I++MzVpQuGhU+QqZMxEA4Z7CRneC9VkGjCFMhwnN5ag= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFaTCCA1GgAwIBAgIJAMMDmu5QkG4oMA0GCSqGSIb3DQEBBQUAMFIxCzAJBgNV +BAYTAlNLMRMwEQYDVQQHEwpCcmF0aXNsYXZhMRMwEQYDVQQKEwpEaXNpZyBhLnMu +MRkwFwYDVQQDExBDQSBEaXNpZyBSb290IFIxMB4XDTEyMDcxOTA5MDY1NloXDTQy +MDcxOTA5MDY1NlowUjELMAkGA1UEBhMCU0sxEzARBgNVBAcTCkJyYXRpc2xhdmEx +EzARBgNVBAoTCkRpc2lnIGEucy4xGTAXBgNVBAMTEENBIERpc2lnIFJvb3QgUjEw +ggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCqw3j33Jijp1pedxiy3QRk +D2P9m5YJgNXoqqXinCaUOuiZc4yd39ffg/N4T0Dhf9Kn0uXKE5Pn7cZ3Xza1lK/o +OI7bm+V8u8yN63Vz4STN5qctGS7Y1oprFOsIYgrY3LMATcMjfF9DCCMyEtztDK3A +fQ+lekLZWnDZv6fXARz2m6uOt0qGeKAeVjGu74IKgEH3G8muqzIm1Cxr7X1r5OJe +IgpFy4QxTaz+29FHuvlglzmxZcfe+5nkCiKxLU3lSCZpq+Kq8/v8kiky6bM+TR8n +oc2OuRf7JT7JbvN32g0S9l3HuzYQ1VTW8+DiR0jm3hTaYVKvJrT1cU/J19IG32PK +/yHoWQbgCNWEFVP3Q+V8xaCJmGtzxmjOZd69fwX3se72V6FglcXM6pM6vpmumwKj +rckWtc7dXpl4fho5frLABaTAgqWjR56M6ly2vGfb5ipN0gTco65F97yLnByn1tUD +3AjLLhbKXEAz6GfDLuemROoRRRw1ZS0eRWEkG4IupZ0zXWX4Qfkuy5Q/H6MMMSRE +7cderVC6xkGbrPAXZcD4XW9boAo0PO7X6oifmPmvTiT6l7Jkdtqr9O3jw2Dv1fkC +yC2fg69naQanMVXVz0tv/wQFx1isXxYb5dKj6zHbHzMVTdDypVP1y+E9Tmgt2BLd +qvLmTZtJ5cUoobqwWsagtQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1Ud +DwEB/wQEAwIBBjAdBgNVHQ4EFgQUiQq0OJMa5qvum5EY+fU8PjXQ04IwDQYJKoZI +hvcNAQEFBQADggIBADKL9p1Kyb4U5YysOMo6CdQbzoaz3evUuii+Eq5FLAR0rBNR +xVgYZk2C2tXck8An4b58n1KeElb21Zyp9HWc+jcSjxyT7Ff+Bw+r1RL3D65hXlaA +SfX8MPWbTx9BLxyE04nH4toCdu0Jz2zBuByDHBb6lM19oMgY0sidbvW9adRtPTXo +HqJPYNcHKfyyo6SdbhWSVhlMCrDpfNIZTUJG7L399ldb3Zh+pE3McgODWF3vkzpB +emOqfDqo9ayk0d2iLbYq/J8BjuIQscTK5GfbVSUZP/3oNn6z4eGBrxEWi1CXYBmC +AMBrTXO40RMHPuq2MU/wQppt4hF05ZSsjYSVPCGvxdpHyN85YmLLW1AL14FABZyb +7bq2ix4Eb5YgOe2kfSnbSM6C3NQCjR0EMVrHS/BsYVLXtFHCgWzN4funodKSds+x +DzdYpPJScWc/DIh4gInByLUfkmO+p3qKViwaqKactV2zY9ATIKHrkWzQjX2v3wvk +F7mGnjixlAxYjOBVqjtjbZqJYLhkKpLGN/R+Q0O3c+gB53+XD9fyexn9GtePyfqF +a3qdnom2piiZk4hA9z7NUaPK6u95RyG1/jLix8NRb76AdPCkwzryT+lf3xkK8jsT +Q6wxpLPn6/wY1gGp8yqPNg7rtLG8t0zJa7+h89n07eLw4+1knj0vllJPgFOL +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFaTCCA1GgAwIBAgIJAJK4iNuwisFjMA0GCSqGSIb3DQEBCwUAMFIxCzAJBgNV +BAYTAlNLMRMwEQYDVQQHEwpCcmF0aXNsYXZhMRMwEQYDVQQKEwpEaXNpZyBhLnMu +MRkwFwYDVQQDExBDQSBEaXNpZyBSb290IFIyMB4XDTEyMDcxOTA5MTUzMFoXDTQy +MDcxOTA5MTUzMFowUjELMAkGA1UEBhMCU0sxEzARBgNVBAcTCkJyYXRpc2xhdmEx +EzARBgNVBAoTCkRpc2lnIGEucy4xGTAXBgNVBAMTEENBIERpc2lnIFJvb3QgUjIw +ggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCio8QACdaFXS1tFPbCw3Oe +NcJxVX6B+6tGUODBfEl45qt5WDza/3wcn9iXAng+a0EE6UG9vgMsRfYvZNSrXaNH +PWSb6WiaxswbP7q+sos0Ai6YVRn8jG+qX9pMzk0DIaPY0jSTVpbLTAwAFjxfGs3I +x2ymrdMxp7zo5eFm1tL7A7RBZckQrg4FY8aAamkw/dLukO8NJ9+flXP04SXabBbe +QTg06ov80egEFGEtQX6sx3dOy1FU+16SGBsEWmjGycT6txOgmLcRK7fWV8x8nhfR +yyX+hk4kLlYMeE2eARKmK6cBZW58Yh2EhN/qwGu1pSqVg8NTEQxzHQuyRpDRQjrO +QG6Vrf/GlK1ul4SOfW+eioANSW1z4nuSHsPzwfPrLgVv2RvPN3YEyLRa5Beny912 +H9AZdugsBbPWnDTYltxhh5EF5EQIM8HauQhl1K6yNg3ruji6DOWbnuuNZt2Zz9aJ +QfYEkoopKW1rOhzndX0CcQ7zwOe9yxndnWCywmZgtrEE7snmhrmaZkCo5xHtgUUD +i/ZnWejBBhG93c+AAk9lQHhcR1DIm+YfgXvkRKhbhZri3lrVx/k6RGZL5DJUfORs +nLMOPReisjQS1n6yqEm70XooQL6iFh/f5DcfEXP7kAplQ6INfPgGAVUzfbANuPT1 +rqVCV3w2EYx7XsQDnYx5nQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1Ud +DwEB/wQEAwIBBjAdBgNVHQ4EFgQUtZn4r7CU9eMg1gqtzk5WpC5uQu0wDQYJKoZI +hvcNAQELBQADggIBACYGXnDnZTPIgm7ZnBc6G3pmsgH2eDtpXi/q/075KMOYKmFM +tCQSin1tERT3nLXK5ryeJ45MGcipvXrA1zYObYVybqjGom32+nNjf7xueQgcnYqf +GopTpti72TVVsRHFqQOzVju5hJMiXn7B9hJSi+osZ7z+Nkz1uM/Rs0mSO9MpDpkb +lvdhuDvEK7Z4bLQjb/D907JedR+Zlais9trhxTF7+9FGs9K8Z7RiVLoJ92Owk6Ka ++elSLotgEqv89WBW7xBci8QaQtyDW2QOy7W81k/BfDxujRNt+3vrMNDcTa/F1bal +TFtxyegxvug4BkihGuLq0t4SOVga/4AOgnXmt8kHbA7v/zjxmHHEt38OFdAlab0i +nSvtBfZGR6ztwPDUO+Ls7pZbkBNOHlY667DvlruWIxG68kOGdGSVyCh13x01utI3 +gzhTODY7z2zp+WsO0PsE6E9312UBeIYMej4hYvF/Y3EMyZ9E26gnonW+boE+18Dr +G5gPcFw0sorMwIUY6256s/daoQe/qUKS82Ail+QUoQebTnbAjn39pCXHR+3/H3Os +zMOl6W8KjptlwlCFtaOgUxLMVYdh84GuEEZhvUQhuMI9dM9+JDX6HAcOmz0iyu8x +L4ysEr3vQCj8KWefshNPZiTEUxnpHikV7+ZtsH8tZ/3zbBt1RqPlShfppNcL +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFjTCCA3WgAwIBAgIEGErM1jANBgkqhkiG9w0BAQsFADBWMQswCQYDVQQGEwJD +TjEwMC4GA1UECgwnQ2hpbmEgRmluYW5jaWFsIENlcnRpZmljYXRpb24gQXV0aG9y +aXR5MRUwEwYDVQQDDAxDRkNBIEVWIFJPT1QwHhcNMTIwODA4MDMwNzAxWhcNMjkx +MjMxMDMwNzAxWjBWMQswCQYDVQQGEwJDTjEwMC4GA1UECgwnQ2hpbmEgRmluYW5j +aWFsIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MRUwEwYDVQQDDAxDRkNBIEVWIFJP +T1QwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDXXWvNED8fBVnVBU03 +sQ7smCuOFR36k0sXgiFxEFLXUWRwFsJVaU2OFW2fvwwbwuCjZ9YMrM8irq93VCpL +TIpTUnrD7i7es3ElweldPe6hL6P3KjzJIx1qqx2hp/Hz7KDVRM8Vz3IvHWOX6Jn5 +/ZOkVIBMUtRSqy5J35DNuF++P96hyk0g1CXohClTt7GIH//62pCfCqktQT+x8Rgp +7hZZLDRJGqgG16iI0gNyejLi6mhNbiyWZXvKWfry4t3uMCz7zEasxGPrb382KzRz +EpR/38wmnvFyXVBlWY9ps4deMm/DGIq1lY+wejfeWkU7xzbh72fROdOXW3NiGUgt +hxwG+3SYIElz8AXSG7Ggo7cbcNOIabla1jj0Ytwli3i/+Oh+uFzJlU9fpy25IGvP +a931DfSCt/SyZi4QKPaXWnuWFo8BGS1sbn85WAZkgwGDg8NNkt0yxoekN+kWzqot +aK8KgWU6cMGbrU1tVMoqLUuFG7OA5nBFDWteNfB/O7ic5ARwiRIlk9oKmSJgamNg +TnYGmE69g60dWIolhdLHZR4tjsbftsbhf4oEIRUpdPA+nJCdDC7xij5aqgwJHsfV +PKPtl8MeNPo4+QgO48BdK4PRVmrJtqhUUy54Mmc9gn900PvhtgVguXDbjgv5E1hv +cWAQUhC5wUEJ73IfZzF4/5YFjQIDAQABo2MwYTAfBgNVHSMEGDAWgBTj/i39KNAL +tbq2osS/BqoFjJP7LzAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjAd +BgNVHQ4EFgQU4/4t/SjQC7W6tqLEvwaqBYyT+y8wDQYJKoZIhvcNAQELBQADggIB +ACXGumvrh8vegjmWPfBEp2uEcwPenStPuiB/vHiyz5ewG5zz13ku9Ui20vsXiObT +ej/tUxPQ4i9qecsAIyjmHjdXNYmEwnZPNDatZ8POQQaIxffu2Bq41gt/UP+TqhdL +jOztUmCypAbqTuv0axn96/Ua4CUqmtzHQTb3yHQFhDmVOdYLO6Qn+gjYXB74BGBS +ESgoA//vU2YApUo0FmZ8/Qmkrp5nGm9BC2sGE5uPhnEFtC+NiWYzKXZUmhH4J/qy +P5Hgzg0b8zAarb8iXRvTvyUFTeGSGn+ZnzxEk8rUQElsgIfXBDrDMlI1Dlb4pd19 +xIsNER9Tyx6yF7Zod1rg1MvIB671Oi6ON7fQAUtDKXeMOZePglr4UeWJoBjnaH9d +Ci77o0cOPaYjesYBx4/IXr9tgFa+iiS6M+qf4TIRnvHST4D2G0CvOJ4RUHlzEhLN +5mydLIhyPDCBBpEi6lmt2hkuIsKNuYyH4Ga8cyNfIWRjgEj1oDwYPZTISEEdQLpe +/v5WOaHIz16eGWRGENoXkbcFgKyLmZJ956LYBws2J+dIeWCKw9cTXPhyQN9Ky8+Z +AAoACxGV2lZFA4gKn2fQ1XmxqI1AbQ3CekD6819kR5LLU7m7Wc5P/dAVUwHY3+vZ +5nbv0CO7O6l5s9UCKc2Jo5YPSjXnTkLAdc0Hz+Ys63su +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDVTCCAj2gAwIBAgIESTMAATANBgkqhkiG9w0BAQUFADAyMQswCQYDVQQGEwJD +TjEOMAwGA1UEChMFQ05OSUMxEzARBgNVBAMTCkNOTklDIFJPT1QwHhcNMDcwNDE2 +MDcwOTE0WhcNMjcwNDE2MDcwOTE0WjAyMQswCQYDVQQGEwJDTjEOMAwGA1UEChMF +Q05OSUMxEzARBgNVBAMTCkNOTklDIFJPT1QwggEiMA0GCSqGSIb3DQEBAQUAA4IB +DwAwggEKAoIBAQDTNfc/c3et6FtzF8LRb+1VvG7q6KR5smzDo+/hn7E7SIX1mlwh +IhAsxYLO2uOabjfhhyzcuQxauohV3/2q2x8x6gHx3zkBwRP9SFIhxFXf2tizVHa6 +dLG3fdfA6PZZxU3Iva0fFNrfWEQlMhkqx35+jq44sDB7R3IJMfAw28Mbdim7aXZO +V/kbZKKTVrdvmW7bCgScEeOAH8tjlBAKqeFkgjH5jCftppkA9nCTGPihNIaj3XrC +GHn2emU1z5DrvTOTn1OrczvmmzQgLx3vqR1jGqCA2wMv+SYahtKNu6m+UjqHZ0gN +v7Sg2Ca+I19zN38m5pIEo3/PIKe38zrKy5nLAgMBAAGjczBxMBEGCWCGSAGG+EIB +AQQEAwIABzAfBgNVHSMEGDAWgBRl8jGtKvf33VKWCscCwQ7vptU7ETAPBgNVHRMB +Af8EBTADAQH/MAsGA1UdDwQEAwIB/jAdBgNVHQ4EFgQUZfIxrSr3991SlgrHAsEO +76bVOxEwDQYJKoZIhvcNAQEFBQADggEBAEs17szkrr/Dbq2flTtLP1se31cpolnK +OOK5Gv+e5m4y3R6u6jW39ZORTtpC4cMXYFDy0VwmuYK36m3knITnA3kXr5g9lNvH +ugDnuL8BV8F3RTIMO/G0HAiw/VGgod2aHRM2mm23xzy54cXZF/qD1T0VoDy7Hgvi +yJA/qIYM/PmLXoXLT1tLYhFHxUV8BS9BsZ4QaRuZluBVeftOhpm4lNqGOGqTo+fL +buXf6iFViZx9fX+Y9QCJ7uOEwFyWtcVG6kbghVW2G8kS1sHNzYDzAgE8yGnLRUhj +2JTQ7IUOO04RZfSCjKY9ri4ilAnIXOo8gV0WKgOXFlUJ24pBgp5mmxE= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEHTCCAwWgAwIBAgIQToEtioJl4AsC7j41AkblPTANBgkqhkiG9w0BAQUFADCB +gTELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4G +A1UEBxMHU2FsZm9yZDEaMBgGA1UEChMRQ09NT0RPIENBIExpbWl0ZWQxJzAlBgNV +BAMTHkNPTU9ETyBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0wNjEyMDEwMDAw +MDBaFw0yOTEyMzEyMzU5NTlaMIGBMQswCQYDVQQGEwJHQjEbMBkGA1UECBMSR3Jl +YXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHEwdTYWxmb3JkMRowGAYDVQQKExFDT01P +RE8gQ0EgTGltaXRlZDEnMCUGA1UEAxMeQ09NT0RPIENlcnRpZmljYXRpb24gQXV0 +aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0ECLi3LjkRv3 +UcEbVASY06m/weaKXTuH+7uIzg3jLz8GlvCiKVCZrts7oVewdFFxze1CkU1B/qnI +2GqGd0S7WWaXUF601CxwRM/aN5VCaTwwxHGzUvAhTaHYujl8HJ6jJJ3ygxaYqhZ8 +Q5sVW7euNJH+1GImGEaaP+vB+fGQV+useg2L23IwambV4EajcNxo2f8ESIl33rXp ++2dtQem8Ob0y2WIC8bGoPW43nOIv4tOiJovGuFVDiOEjPqXSJDlqR6sA1KGzqSX+ +DT+nHbrTUcELpNqsOO9VUCQFZUaTNE8tja3G1CEZ0o7KBWFxB3NH5YoZEr0ETc5O +nKVIrLsm9wIDAQABo4GOMIGLMB0GA1UdDgQWBBQLWOWLxkwVN6RAqTCpIb5HNlpW +/zAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zBJBgNVHR8EQjBAMD6g +PKA6hjhodHRwOi8vY3JsLmNvbW9kb2NhLmNvbS9DT01PRE9DZXJ0aWZpY2F0aW9u +QXV0aG9yaXR5LmNybDANBgkqhkiG9w0BAQUFAAOCAQEAPpiem/Yb6dc5t3iuHXIY +SdOH5EOC6z/JqvWote9VfCFSZfnVDeFs9D6Mk3ORLgLETgdxb8CPOGEIqB6BCsAv +IC9Bi5HcSEW88cbeunZrM8gALTFGTO3nnc+IlP8zwFboJIYmuNg4ON8qa90SzMc/ +RxdMosIGlgnW2/4/PEZB31jiVg88O8EckzXZOFKs7sjsLjBOlDW0JB9LeGna8gI4 +zJVSk/BwJVmcIGfE7vmLV2H0knZ9P4SNVbfo5azV8fUZVqZa+5Acr5Pr5RzUZ5dd +BA6+C4OmF4O5MBKgxTMVBbkN+8cFduPYSo38NBejxiEovjBFMR7HeL5YYTisO+IB +ZQ== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICiTCCAg+gAwIBAgIQH0evqmIAcFBUTAGem2OZKjAKBggqhkjOPQQDAzCBhTEL +MAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UE +BxMHU2FsZm9yZDEaMBgGA1UEChMRQ09NT0RPIENBIExpbWl0ZWQxKzApBgNVBAMT +IkNPTU9ETyBFQ0MgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDgwMzA2MDAw +MDAwWhcNMzgwMTE4MjM1OTU5WjCBhTELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdy +ZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UEBxMHU2FsZm9yZDEaMBgGA1UEChMRQ09N +T0RPIENBIExpbWl0ZWQxKzApBgNVBAMTIkNPTU9ETyBFQ0MgQ2VydGlmaWNhdGlv +biBBdXRob3JpdHkwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQDR3svdcmCFYX7deSR +FtSrYpn1PlILBs5BAH+X4QokPB0BBO490o0JlwzgdeT6+3eKKvUDYEs2ixYjFq0J +cfRK9ChQtP6IHG4/bC8vCVlbpVsLM5niwz2J+Wos77LTBumjQjBAMB0GA1UdDgQW +BBR1cacZSBm8nZ3qQUfflMRId5nTeTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/ +BAUwAwEB/zAKBggqhkjOPQQDAwNoADBlAjEA7wNbeqy3eApyt4jf/7VGFAkK+qDm +fQjGGoe9GKhzvSbKYAydzpmfz1wPMOG+FDHqAjAU9JM8SaczepBGR7NjfRObTrdv +GDeAU/7dIOA1mjbRxwG55tzd8/8dLDoWV9mSOdY= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIF2DCCA8CgAwIBAgIQTKr5yttjb+Af907YWwOGnTANBgkqhkiG9w0BAQwFADCB +hTELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4G +A1UEBxMHU2FsZm9yZDEaMBgGA1UEChMRQ09NT0RPIENBIExpbWl0ZWQxKzApBgNV +BAMTIkNPTU9ETyBSU0EgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMTAwMTE5 +MDAwMDAwWhcNMzgwMTE4MjM1OTU5WjCBhTELMAkGA1UEBhMCR0IxGzAZBgNVBAgT +EkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UEBxMHU2FsZm9yZDEaMBgGA1UEChMR +Q09NT0RPIENBIExpbWl0ZWQxKzApBgNVBAMTIkNPTU9ETyBSU0EgQ2VydGlmaWNh +dGlvbiBBdXRob3JpdHkwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCR +6FSS0gpWsawNJN3Fz0RndJkrN6N9I3AAcbxT38T6KhKPS38QVr2fcHK3YX/JSw8X +pz3jsARh7v8Rl8f0hj4K+j5c+ZPmNHrZFGvnnLOFoIJ6dq9xkNfs/Q36nGz637CC +9BR++b7Epi9Pf5l/tfxnQ3K9DADWietrLNPtj5gcFKt+5eNu/Nio5JIk2kNrYrhV +/erBvGy2i/MOjZrkm2xpmfh4SDBF1a3hDTxFYPwyllEnvGfDyi62a+pGx8cgoLEf +Zd5ICLqkTqnyg0Y3hOvozIFIQ2dOciqbXL1MGyiKXCJ7tKuY2e7gUYPDCUZObT6Z ++pUX2nwzV0E8jVHtC7ZcryxjGt9XyD+86V3Em69FmeKjWiS0uqlWPc9vqv9JWL7w +qP/0uK3pN/u6uPQLOvnoQ0IeidiEyxPx2bvhiWC4jChWrBQdnArncevPDt09qZah +SL0896+1DSJMwBGB7FY79tOi4lu3sgQiUpWAk2nojkxl8ZEDLXB0AuqLZxUpaVIC +u9ffUGpVRr+goyhhf3DQw6KqLCGqR84onAZFdr+CGCe01a60y1Dma/RMhnEw6abf +Fobg2P9A3fvQQoh/ozM6LlweQRGBY84YcWsr7KaKtzFcOmpH4MN5WdYgGq/yapiq +crxXStJLnbsQ/LBMQeXtHT1eKJ2czL+zUdqnR+WEUwIDAQABo0IwQDAdBgNVHQ4E +FgQUu69+Aj36pvE8hI6t7jiY7NkyMtQwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB +/wQFMAMBAf8wDQYJKoZIhvcNAQEMBQADggIBAArx1UaEt65Ru2yyTUEUAJNMnMvl +wFTPoCWOAvn9sKIN9SCYPBMtrFaisNZ+EZLpLrqeLppysb0ZRGxhNaKatBYSaVqM +4dc+pBroLwP0rmEdEBsqpIt6xf4FpuHA1sj+nq6PK7o9mfjYcwlYRm6mnPTXJ9OV +2jeDchzTc+CiR5kDOF3VSXkAKRzH7JsgHAckaVd4sjn8OoSgtZx8jb8uk2Intzna +FxiuvTwJaP+EmzzV1gsD41eeFPfR60/IvYcjt7ZJQ3mFXLrrkguhxuhoqEwWsRqZ +CuhTLJK7oQkYdQxlqHvLI7cawiiFwxv/0Cti76R7CZGYZ4wUAc1oBmpjIXUDgIiK +boHGhfKppC3n9KUkEEeDys30jXlYsQab5xoq2Z0B15R97QNKyvDb6KkBPvVWmcke +jkk9u+UJueBPSZI9FoJAzMxZxuY67RIuaTxslbH9qh17f4a+Hg4yRvv7E491f0yL +S0Zj/gA0QHDBw7mh3aZw4gSzQbzpgJHqZJx64SIDqZxubw5lT2yHh17zbqD5daWb +QOhTsiedSrnAdyGN/4fy3ryM7xfft0kL0fJuMAsaDk527RH89elWsn2/x20Kk4yl +0MC2Hb46TpSi125sC8KKfPog88Tk5c0NqMuRkrF8hey1FGlmDoLnzc7ILaZRfyHB +NVOFBkpdn627G190 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEvTCCA6WgAwIBAgIBADANBgkqhkiG9w0BAQUFADB/MQswCQYDVQQGEwJFVTEn +MCUGA1UEChMeQUMgQ2FtZXJmaXJtYSBTQSBDSUYgQTgyNzQzMjg3MSMwIQYDVQQL +ExpodHRwOi8vd3d3LmNoYW1iZXJzaWduLm9yZzEiMCAGA1UEAxMZQ2hhbWJlcnMg +b2YgQ29tbWVyY2UgUm9vdDAeFw0wMzA5MzAxNjEzNDNaFw0zNzA5MzAxNjEzNDRa +MH8xCzAJBgNVBAYTAkVVMScwJQYDVQQKEx5BQyBDYW1lcmZpcm1hIFNBIENJRiBB +ODI3NDMyODcxIzAhBgNVBAsTGmh0dHA6Ly93d3cuY2hhbWJlcnNpZ24ub3JnMSIw +IAYDVQQDExlDaGFtYmVycyBvZiBDb21tZXJjZSBSb290MIIBIDANBgkqhkiG9w0B +AQEFAAOCAQ0AMIIBCAKCAQEAtzZV5aVdGDDg2olUkfzIx1L4L1DZ77F1c2VHfRtb +unXF/KGIJPov7coISjlUxFF6tdpg6jg8gbLL8bvZkSM/SAFwdakFKq0fcfPJVD0d +BmpAPrMMhe5cG3nCYsS4No41XQEMIwRHNaqbYE6gZj3LJgqcQKH0XZi/caulAGgq +7YN6D6IUtdQis4CwPAxaUWktWBiP7Zme8a7ileb2R6jWDA+wWFjbw2Y3npuRVDM3 +0pQcakjJyfKl2qUMI/cjDpwyVV5xnIQFUZot/eZOKjRa3spAN2cMVCFVd9oKDMyX +roDclDZK9D7ONhMeU+SsTjoF7Nuucpw4i9A5O4kKPnf+dQIBA6OCAUQwggFAMBIG +A1UdEwEB/wQIMAYBAf8CAQwwPAYDVR0fBDUwMzAxoC+gLYYraHR0cDovL2NybC5j +aGFtYmVyc2lnbi5vcmcvY2hhbWJlcnNyb290LmNybDAdBgNVHQ4EFgQU45T1sU3p +26EpW1eLTXYGduHRooowDgYDVR0PAQH/BAQDAgEGMBEGCWCGSAGG+EIBAQQEAwIA +BzAnBgNVHREEIDAegRxjaGFtYmVyc3Jvb3RAY2hhbWJlcnNpZ24ub3JnMCcGA1Ud +EgQgMB6BHGNoYW1iZXJzcm9vdEBjaGFtYmVyc2lnbi5vcmcwWAYDVR0gBFEwTzBN +BgsrBgEEAYGHLgoDATA+MDwGCCsGAQUFBwIBFjBodHRwOi8vY3BzLmNoYW1iZXJz +aWduLm9yZy9jcHMvY2hhbWJlcnNyb290Lmh0bWwwDQYJKoZIhvcNAQEFBQADggEB +AAxBl8IahsAifJ/7kPMa0QOx7xP5IV8EnNrJpY0nbJaHkb5BkAFyk+cefV/2icZd +p0AJPaxJRUXcLo0waLIJuvvDL8y6C98/d3tGfToSJI6WjzwFCm/SlCgdbQzALogi +1djPHRPH8EjX1wWnz8dHnjs8NMiAT9QUu/wNUPf6s+xCX6ndbcj0dc97wXImsQEc +XCz9ek60AcUFV7nnPKoF2YjpB0ZBzu9Bga5Y34OirsrXdx/nADydb47kMgkdTXg0 +eDQ8lJsm7U9xxhl6vSAiSFr+S30Dt+dYvsYyTnQeaN2oaFuzPu5ifdmA6Ap1erfu +tGWaIZDgqtCYvDi1czyL+Nw= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIExTCCA62gAwIBAgIBADANBgkqhkiG9w0BAQUFADB9MQswCQYDVQQGEwJFVTEn +MCUGA1UEChMeQUMgQ2FtZXJmaXJtYSBTQSBDSUYgQTgyNzQzMjg3MSMwIQYDVQQL +ExpodHRwOi8vd3d3LmNoYW1iZXJzaWduLm9yZzEgMB4GA1UEAxMXR2xvYmFsIENo +YW1iZXJzaWduIFJvb3QwHhcNMDMwOTMwMTYxNDE4WhcNMzcwOTMwMTYxNDE4WjB9 +MQswCQYDVQQGEwJFVTEnMCUGA1UEChMeQUMgQ2FtZXJmaXJtYSBTQSBDSUYgQTgy +NzQzMjg3MSMwIQYDVQQLExpodHRwOi8vd3d3LmNoYW1iZXJzaWduLm9yZzEgMB4G +A1UEAxMXR2xvYmFsIENoYW1iZXJzaWduIFJvb3QwggEgMA0GCSqGSIb3DQEBAQUA +A4IBDQAwggEIAoIBAQCicKLQn0KuWxfH2H3PFIP8T8mhtxOviteePgQKkotgVvq0 +Mi+ITaFgCPS3CU6gSS9J1tPfnZdan5QEcOw/Wdm3zGaLmFIoCQLfxS+EjXqXd7/s +QJ0lcqu1PzKY+7e3/HKE5TWH+VX6ox8Oby4o3Wmg2UIQxvi1RMLQQ3/bvOSiPGpV +eAp3qdjqGTK3L/5cPxvusZjsyq16aUXjlg9V9ubtdepl6DJWk0aJqCWKZQbua795 +B9Dxt6/tLE2Su8CoX6dnfQTyFQhwrJLWfQTSM/tMtgsL+xrJxI0DqX5c8lCrEqWh +z0hQpe/SyBoT+rB/sYIcd2oPX9wLlY/vQ37mRQklAgEDo4IBUDCCAUwwEgYDVR0T +AQH/BAgwBgEB/wIBDDA/BgNVHR8EODA2MDSgMqAwhi5odHRwOi8vY3JsLmNoYW1i +ZXJzaWduLm9yZy9jaGFtYmVyc2lnbnJvb3QuY3JsMB0GA1UdDgQWBBRDnDafsJ4w +TcbOX60Qq+UDpfqpFDAOBgNVHQ8BAf8EBAMCAQYwEQYJYIZIAYb4QgEBBAQDAgAH +MCoGA1UdEQQjMCGBH2NoYW1iZXJzaWducm9vdEBjaGFtYmVyc2lnbi5vcmcwKgYD +VR0SBCMwIYEfY2hhbWJlcnNpZ25yb290QGNoYW1iZXJzaWduLm9yZzBbBgNVHSAE +VDBSMFAGCysGAQQBgYcuCgEBMEEwPwYIKwYBBQUHAgEWM2h0dHA6Ly9jcHMuY2hh +bWJlcnNpZ24ub3JnL2Nwcy9jaGFtYmVyc2lnbnJvb3QuaHRtbDANBgkqhkiG9w0B +AQUFAAOCAQEAPDtwkfkEVCeR4e3t/mh/YV3lQWVPMvEYBZRqHN4fcNs+ezICNLUM +bKGKfKX0j//U2K0X1S0E0T9YgOKBWYi+wONGkyT+kL0mojAt6JcmVzWJdJYY9hXi +ryQZVgICsroPFOrGimbBhkVVi76SvpykBMdJPJ7oKXqJ1/6v/2j1pReQvayZzKWG +VwlnRtvWFsJG8eSpUPWP0ZIV018+xgBJOm5YstHRJw0lyDL4IBHNfTIzSJRUTN3c +ecQwn+uOuFW114hcxWokPbLTBQNRxgfvzBRydD1ucs4YKIxKoHflCStFREest2d/ +AYoFWpO+ocH/+OcOZ6RHSXZddZAa9SaP8A== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDqDCCApCgAwIBAgIJAP7c4wEPyUj/MA0GCSqGSIb3DQEBBQUAMDQxCzAJBgNV +BAYTAkZSMRIwEAYDVQQKDAlEaGlteW90aXMxETAPBgNVBAMMCENlcnRpZ25hMB4X +DTA3MDYyOTE1MTMwNVoXDTI3MDYyOTE1MTMwNVowNDELMAkGA1UEBhMCRlIxEjAQ +BgNVBAoMCURoaW15b3RpczERMA8GA1UEAwwIQ2VydGlnbmEwggEiMA0GCSqGSIb3 +DQEBAQUAA4IBDwAwggEKAoIBAQDIaPHJ1tazNHUmgh7stL7qXOEm7RFHYeGifBZ4 +QCHkYJ5ayGPhxLGWkv8YbWkj4Sti993iNi+RB7lIzw7sebYs5zRLcAglozyHGxny +gQcPOJAZ0xH+hrTy0V4eHpbNgGzOOzGTtvKg0KmVEn2lmsxryIRWijOp5yIVUxbw +zBfsV1/pogqYCd7jX5xv3EjjhQsVWqa6n6xI4wmy9/Qy3l40vhx4XUJbzg4ij02Q +130yGLMLLGq/jj8UEYkgDncUtT2UCIf3JR7VsmAA7G8qKCVuKj4YYxclPz5EIBb2 +JsglrgVKtOdjLPOMFlN+XPsRGgjBRmKfIrjxwo1p3Po6WAbfAgMBAAGjgbwwgbkw +DwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGu3+QTmQtCRZvgHyUtVF9lo53BEw +ZAYDVR0jBF0wW4AUGu3+QTmQtCRZvgHyUtVF9lo53BGhOKQ2MDQxCzAJBgNVBAYT +AkZSMRIwEAYDVQQKDAlEaGlteW90aXMxETAPBgNVBAMMCENlcnRpZ25hggkA/tzj +AQ/JSP8wDgYDVR0PAQH/BAQDAgEGMBEGCWCGSAGG+EIBAQQEAwIABzANBgkqhkiG +9w0BAQUFAAOCAQEAhQMeknH2Qq/ho2Ge6/PAD/Kl1NqV5ta+aDY9fm4fTIrv0Q8h +bV6lUmPOEvjvKtpv6zf+EwLHyzs+ImvaYS5/1HI93TDhHkxAGYwP15zRgzB7mFnc +fca5DClMoTOi62c6ZYTTluLtdkVwj7Ur3vkj1kluPBS1xp81HlDQwY9qcEQCYsuu +HWhBp6pX6FOqB9IG9tUUBguRA3UsbHK1YZWaDYu5Def131TN3ubY1gkIl2PlwS6w +t0QmwCbAr1UwnjvVNioZBPRcHv/PLLf/0P2HQBHVESO7SMAhqaQoLf0V+LBOK/Qw +WyH8EZE0vkHve52Xdf+XlcCWWC/qu0bXu+TZLg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFnDCCA4SgAwIBAgIBATANBgkqhkiG9w0BAQUFADBjMQswCQYDVQQGEwJGUjET +MBEGA1UEChMKQ2VydGlub21pczEXMBUGA1UECxMOMDAwMiA0MzM5OTg5MDMxJjAk +BgNVBAMMHUNlcnRpbm9taXMgLSBBdXRvcml0w6kgUmFjaW5lMB4XDTA4MDkxNzA4 +Mjg1OVoXDTI4MDkxNzA4Mjg1OVowYzELMAkGA1UEBhMCRlIxEzARBgNVBAoTCkNl +cnRpbm9taXMxFzAVBgNVBAsTDjAwMDIgNDMzOTk4OTAzMSYwJAYDVQQDDB1DZXJ0 +aW5vbWlzIC0gQXV0b3JpdMOpIFJhY2luZTCCAiIwDQYJKoZIhvcNAQEBBQADggIP +ADCCAgoCggIBAJ2Fn4bT46/HsmtuM+Cet0I0VZ35gb5j2CN2DpdUzZlMGvE5x4jY +F1AMnmHawE5V3udauHpOd4cN5bjr+p5eex7Ezyh0x5P1FMYiKAT5kcOrJ3NqDi5N +8y4oH3DfVS9O7cdxbwlyLu3VMpfQ8Vh30WC8Tl7bmoT2R2FFK/ZQpn9qcSdIhDWe +rP5pqZ56XjUl+rSnSTV3lqc2W+HN3yNw2F1MpQiD8aYkOBOo7C+ooWfHpi2GR+6K +/OybDnT0K0kCe5B1jPyZOQE51kqJ5Z52qz6WKDgmi92NjMD2AR5vpTESOH2VwnHu +7XSu5DaiQ3XV8QCb4uTXzEIDS3h65X27uK4uIJPT5GHfceF2Z5c/tt9qc1pkIuVC +28+BA5PY9OMQ4HL2AHCs8MF6DwV/zzRpRbWT5BnbUhYjBYkOjUjkJW+zeL9i9Qf6 +lSTClrLooyPCXQP8w9PlfMl1I9f09bze5N/NgL+RiH2nE7Q5uiy6vdFrzPOlKO1E +nn1So2+WLhl+HPNbxxaOu2B9d2ZHVIIAEWBsMsGoOBvrbpgT1u449fCfDu/+MYHB +0iSVL1N6aaLwD4ZFjliCK0wi1F6g530mJ0jfJUaNSih8hp75mxpZuWW/Bd22Ql09 +5gBIgl4g9xGC3srYn+Y3RyYe63j3YcNBZFgCQfna4NH4+ej9Uji29YnfAgMBAAGj +WzBZMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBQN +jLZh2kS40RR9w759XkjwzspqsDAXBgNVHSAEEDAOMAwGCiqBegFWAgIAAQEwDQYJ +KoZIhvcNAQEFBQADggIBACQ+YAZ+He86PtvqrxyaLAEL9MW12Ukx9F1BjYkMTv9s +ov3/4gbIOZ/xWqndIlgVqIrTseYyCYIDbNc/CMf4uboAbbnW/FIyXaR/pDGUu7ZM +OH8oMDX/nyNTt7buFHAAQCvaR6s0fl6nVjBhK4tDrP22iCj1a7Y+YEq6QpA0Z43q +619FVDsXrIvkxmUP7tCMXWY5zjKn2BCXwH40nJ+U8/aGH88bc62UeYdocMMzpXDn +2NU4lG9jeeu/Cg4I58UvD0KgKxRA/yHgBcUn4YQRE7rWhh1BCxMjidPJC+iKunqj +o3M3NYB9Ergzd0A4wPpeMNLytqOx1qKVl4GbUu1pTP+A5FPbVFsDbVRfsbjvJL1v +nxHDx2TCDyhihWZeGnuyt++uNckZM6i4J9szVb9o4XVIRFb7zdNIu0eJOqxp9YDG +5ERQL1TEqkPFMTFYvZbF6nVsmnWxTfj3l/+WFvKXTej28xH5On2KOG4Ey+HTRRWq +pdEdnV1j6CTmNhTih60bWfVEm/vXd3wfAXBioSAaosUaKPQhA+4u2cGA6rnZgtZb +dsLLO7XSAPCjDuGtbkD326C00EauFddEwk01+dIL8hf2rGbVJLJP0RyZwG71fet0 +BLj5TXcJ17TPBzAJ8bgAVtkXFhYKK4bfjwEZGuW7gmP/vgt2Fl43N+bYdJeimUV5 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDkjCCAnqgAwIBAgIRAIW9S/PY2uNp9pTXX8OlRCMwDQYJKoZIhvcNAQEFBQAw +PTELMAkGA1UEBhMCRlIxETAPBgNVBAoTCENlcnRwbHVzMRswGQYDVQQDExJDbGFz +cyAyIFByaW1hcnkgQ0EwHhcNOTkwNzA3MTcwNTAwWhcNMTkwNzA2MjM1OTU5WjA9 +MQswCQYDVQQGEwJGUjERMA8GA1UEChMIQ2VydHBsdXMxGzAZBgNVBAMTEkNsYXNz +IDIgUHJpbWFyeSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANxQ +ltAS+DXSCHh6tlJw/W/uz7kRy1134ezpfgSN1sxvc0NXYKwzCkTsA18cgCSR5aiR +VhKC9+Ar9NuuYS6JEI1rbLqzAr3VNsVINyPi8Fo3UjMXEuLRYE2+L0ER4/YXJQyL +kcAbmXuZVg2v7tK8R1fjeUl7NIknJITesezpWE7+Tt9avkGtrAjFGA7v0lPubNCd +EgETjdyAYveVqUSISnFOYFWe2yMZeVYHDD9jC1yw4r5+FfyUM1hBOHTE4Y+L3yas +H7WLO7dDWWuwJKZtkIvEcupdM5i3y95ee++U8Rs+yskhwcWYAqqi9lt3m/V+llU0 +HGdpwPFC40es/CgcZlUCAwEAAaOBjDCBiTAPBgNVHRMECDAGAQH/AgEKMAsGA1Ud +DwQEAwIBBjAdBgNVHQ4EFgQU43Mt38sOKAze3bOkynm4jrvoMIkwEQYJYIZIAYb4 +QgEBBAQDAgEGMDcGA1UdHwQwMC4wLKAqoCiGJmh0dHA6Ly93d3cuY2VydHBsdXMu +Y29tL0NSTC9jbGFzczIuY3JsMA0GCSqGSIb3DQEBBQUAA4IBAQCnVM+IRBnL39R/ +AN9WM2K191EBkOvDP9GIROkkXe/nFL0gt5o8AP5tn9uQ3Nf0YtaLcF3n5QRIqWh8 +yfFC82x/xXp8HVGIutIKPidd3i1RTtMTZGnkLuPT55sJmabglZvOGtd/vjzOUrMR +FcEPF80Du5wlFbqidon8BvEY0JNLDnyCt6X09l/+7UCmnYR0ObncHoUW2ikbhiMA +ybuJfm6AiB4vFLQDJKgybwOaRywwvlbGp0ICcBvqQNi6BQNwB6SW//1IMwrh3KWB +kJtN3X3n57LNXMhqlfil9o3EXXgIvnsG1knPGTZQIy4I5p4FTUcY1Rbpsda2ENW7 +l7+ijrRU +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDDDCCAfSgAwIBAgIDAQAgMA0GCSqGSIb3DQEBBQUAMD4xCzAJBgNVBAYTAlBM +MRswGQYDVQQKExJVbml6ZXRvIFNwLiB6IG8uby4xEjAQBgNVBAMTCUNlcnR1bSBD +QTAeFw0wMjA2MTExMDQ2MzlaFw0yNzA2MTExMDQ2MzlaMD4xCzAJBgNVBAYTAlBM +MRswGQYDVQQKExJVbml6ZXRvIFNwLiB6IG8uby4xEjAQBgNVBAMTCUNlcnR1bSBD +QTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAM6xwS7TT3zNJc4YPk/E +jG+AanPIW1H4m9LcuwBcsaD8dQPugfCI7iNS6eYVM42sLQnFdvkrOYCJ5JdLkKWo +ePhzQ3ukYbDYWMzhbGZ+nPMJXlVjhNWo7/OxLjBos8Q82KxujZlakE403Daaj4GI +ULdtlkIJ89eVgw1BS7Bqa/j8D35in2fE7SZfECYPCE/wpFcozo+47UX2bu4lXapu +Ob7kky/ZR6By6/qmW6/KUz/iDsaWVhFu9+lmqSbYf5VT7QqFiLpPKaVCjF62/IUg +AKpoC6EahQGcxEZjgoi2IrHu/qpGWX7PNSzVttpd90gzFFS269lvzs2I1qsb2pY7 +HVkCAwEAAaMTMBEwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQUFAAOCAQEA +uI3O7+cUus/usESSbLQ5PqKEbq24IXfS1HeCh+YgQYHu4vgRt2PRFze+GXYkHAQa +TOs9qmdvLdTN/mUxcMUbpgIKumB7bVjCmkn+YzILa+M6wKyrO7Do0wlRjBCDxjTg +xSvgGrZgFCdsMneMvLJymM/NzD+5yCRCFNZX/OYmQ6kd5YCQzgNUKD73P9P4Te1q +CjqTE5s7FCMTY5w/0YcneeVMUeMBrYVdGjux1XMQpNPyvG5k9VpWkKjHDkx0Dy5x +O/fIR/RpbxXyEV6DHpx8Uq79AtoSqFlnGNu8cN2bsWntgM6JQEhqDjXKKWYVIZQs +6GAqm4VKQPNriiTsBhYscw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDuzCCAqOgAwIBAgIDBETAMA0GCSqGSIb3DQEBBQUAMH4xCzAJBgNVBAYTAlBM +MSIwIAYDVQQKExlVbml6ZXRvIFRlY2hub2xvZ2llcyBTLkEuMScwJQYDVQQLEx5D +ZXJ0dW0gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkxIjAgBgNVBAMTGUNlcnR1bSBU +cnVzdGVkIE5ldHdvcmsgQ0EwHhcNMDgxMDIyMTIwNzM3WhcNMjkxMjMxMTIwNzM3 +WjB+MQswCQYDVQQGEwJQTDEiMCAGA1UEChMZVW5pemV0byBUZWNobm9sb2dpZXMg +Uy5BLjEnMCUGA1UECxMeQ2VydHVtIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MSIw +IAYDVQQDExlDZXJ0dW0gVHJ1c3RlZCBOZXR3b3JrIENBMIIBIjANBgkqhkiG9w0B +AQEFAAOCAQ8AMIIBCgKCAQEA4/t9o3K6wvDJFIf1awFO4W5AB7ptJ11/91sts1rH +UV+rpDKmYYe2bg+G0jACl/jXaVehGDldamR5xgFZrDwxSjh80gTSSyjoIF87B6LM +TXPb865Px1bVWqeWifrzq2jUI4ZZJ88JJ7ysbnKDHDBy3+Ci6dLhdHUZvSqeexVU +BBvXQzmtVSjF4hq79MDkrjhJM8x2hZ85RdKknvISjFH4fOQtf/WsX+sWn7Et0brM +kUJ3TCXJkDhv2/DM+44el1k+1WBO5gUo7Ul5E0u6SNsv+XLTOcr+H9g0cvW0QM8x +AcPs3hEtF10fuFDRXhmnad4HMyjKUJX5p1TLVIZQRan5SQIDAQABo0IwQDAPBgNV +HRMBAf8EBTADAQH/MB0GA1UdDgQWBBQIds3LB/8k9sXN7buQvOKEN0Z19zAOBgNV +HQ8BAf8EBAMCAQYwDQYJKoZIhvcNAQEFBQADggEBAKaorSLOAT2mo/9i0Eidi15y +sHhE49wcrwn9I0j6vSrEuVUEtRCjjSfeC4Jj0O7eDDd5QVsisrCaQVymcODU0HfL +I9MA4GxWL+FpDQ3Zqr8hgVDZBqWo/5U30Kr+4rP1mS1FhIrlQgnXdAIv94nYmem8 +J9RHjboNRhx3zxSkHLmkMcScKHQDNP8zGSal6Q10tz6XxnboJ5ajZt3hrvJBW8qY +VoNzcOSGGtIxQbovvi0TWnZvTuhOgQ4/WwMioBK+ZlgRSssDxLQqKi2WF+A5VLxI +03YnnZotBqbJ7DnSq9ufmgsnAjUpsUCV5/nonFWIGUbWtzT1fs45mtk48VH3Tyw= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIHTzCCBTegAwIBAgIJAKPaQn6ksa7aMA0GCSqGSIb3DQEBBQUAMIGuMQswCQYD +VQQGEwJFVTFDMEEGA1UEBxM6TWFkcmlkIChzZWUgY3VycmVudCBhZGRyZXNzIGF0 +IHd3dy5jYW1lcmZpcm1hLmNvbS9hZGRyZXNzKTESMBAGA1UEBRMJQTgyNzQzMjg3 +MRswGQYDVQQKExJBQyBDYW1lcmZpcm1hIFMuQS4xKTAnBgNVBAMTIENoYW1iZXJz +IG9mIENvbW1lcmNlIFJvb3QgLSAyMDA4MB4XDTA4MDgwMTEyMjk1MFoXDTM4MDcz +MTEyMjk1MFowga4xCzAJBgNVBAYTAkVVMUMwQQYDVQQHEzpNYWRyaWQgKHNlZSBj +dXJyZW50IGFkZHJlc3MgYXQgd3d3LmNhbWVyZmlybWEuY29tL2FkZHJlc3MpMRIw +EAYDVQQFEwlBODI3NDMyODcxGzAZBgNVBAoTEkFDIENhbWVyZmlybWEgUy5BLjEp +MCcGA1UEAxMgQ2hhbWJlcnMgb2YgQ29tbWVyY2UgUm9vdCAtIDIwMDgwggIiMA0G +CSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCvAMtwNyuAWko6bHiUfaN/Gh/2NdW9 +28sNRHI+JrKQUrpjOyhYb6WzbZSm891kDFX29ufyIiKAXuFixrYp4YFs8r/lfTJq +VKAyGVn+H4vXPWCGhSRv4xGzdz4gljUha7MI2XAuZPeEklPWDrCQiorjh40G072Q +DuKZoRuGDtqaCrsLYVAGUvGef3bsyw/QHg3PmTA9HMRFEFis1tPo1+XqxQEHd9ZR +5gN/ikilTWh1uem8nk4ZcfUyS5xtYBkL+8ydddy/Js2Pk3g5eXNeJQ7KXOt3EgfL +ZEFHcpOrUMPrCXZkNNI5t3YRCQ12RcSprj1qr7V9ZS+UWBDsXHyvfuK2GNnQm05a +Sd+pZgvMPMZ4fKecHePOjlO+Bd5gD2vlGts/4+EhySnB8esHnFIbAURRPHsl18Tl +UlRdJQfKFiC4reRB7noI/plvg6aRArBsNlVq5331lubKgdaX8ZSD6e2wsWsSaR6s ++12pxZjptFtYer49okQ6Y1nUCyXeG0+95QGezdIp1Z8XGQpvvwyQ0wlf2eOKNcx5 +Wk0ZN5K3xMGtr/R5JJqyAQuxr1yW84Ay+1w9mPGgP0revq+ULtlVmhduYJ1jbLhj +ya6BXBg14JC7vjxPNyK5fuvPnnchpj04gftI2jE9K+OJ9dC1vX7gUMQSibMjmhAx +hduub+84Mxh2EQIDAQABo4IBbDCCAWgwEgYDVR0TAQH/BAgwBgEB/wIBDDAdBgNV +HQ4EFgQU+SSsD7K1+HnA+mCIG8TZTQKeFxkwgeMGA1UdIwSB2zCB2IAU+SSsD7K1 ++HnA+mCIG8TZTQKeFxmhgbSkgbEwga4xCzAJBgNVBAYTAkVVMUMwQQYDVQQHEzpN +YWRyaWQgKHNlZSBjdXJyZW50IGFkZHJlc3MgYXQgd3d3LmNhbWVyZmlybWEuY29t +L2FkZHJlc3MpMRIwEAYDVQQFEwlBODI3NDMyODcxGzAZBgNVBAoTEkFDIENhbWVy +ZmlybWEgUy5BLjEpMCcGA1UEAxMgQ2hhbWJlcnMgb2YgQ29tbWVyY2UgUm9vdCAt +IDIwMDiCCQCj2kJ+pLGu2jAOBgNVHQ8BAf8EBAMCAQYwPQYDVR0gBDYwNDAyBgRV +HSAAMCowKAYIKwYBBQUHAgEWHGh0dHA6Ly9wb2xpY3kuY2FtZXJmaXJtYS5jb20w +DQYJKoZIhvcNAQEFBQADggIBAJASryI1wqM58C7e6bXpeHxIvj99RZJe6dqxGfwW +PJ+0W2aeaufDuV2I6A+tzyMP3iU6XsxPpcG1Lawk0lgH3qLPaYRgM+gQDROpI9CF +5Y57pp49chNyM/WqfcZjHwj0/gF/JM8rLFQJ3uIrbZLGOU8W6jx+ekbURWpGqOt1 +glanq6B8aBMz9p0w8G8nOSQjKpD9kCk18pPfNKXG9/jvjA9iSnyu0/VU+I22mlaH +FoI6M6taIgj3grrqLuBHmrS1RaMFO9ncLkVAO+rcf+g769HsJtg1pDDFOqxXnrN2 +pSB7+R5KBWIBpih1YJeSDW4+TTdDDZIVnBgizVGZoCkaPF+KMjNbMMeJL0eYD6MD +xvbxrN8y8NmBGuScvfaAFPDRLLmF9dijscilIeUcE5fuDr3fKanvNFNb0+RqE4QG +tjICxFKuItLcsiFCGtpA8CnJ7AoMXOLQusxI0zcKzBIKinmwPQN/aUv0NCB9szTq +jktk9T79syNnFQ0EuPAtwQlRPLJsFfClI9eDdOTlLsn+mCdCxqvGnrDQWzilm1De +fhiYtUU79nm06PcaewaD+9CL2rvHvRirCG88gGtAPxkZumWK5r7VXNM21+9AUiRg +OGcEMeyP84LG3rlV8zsxkVrctQgVrXYlCg17LofiDKYGvCYQbTed7N14jHyAxfDZ +d0jQ +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIID9zCCAt+gAwIBAgIESJ8AATANBgkqhkiG9w0BAQUFADCBijELMAkGA1UEBhMC +Q04xMjAwBgNVBAoMKUNoaW5hIEludGVybmV0IE5ldHdvcmsgSW5mb3JtYXRpb24g +Q2VudGVyMUcwRQYDVQQDDD5DaGluYSBJbnRlcm5ldCBOZXR3b3JrIEluZm9ybWF0 +aW9uIENlbnRlciBFViBDZXJ0aWZpY2F0ZXMgUm9vdDAeFw0xMDA4MzEwNzExMjVa +Fw0zMDA4MzEwNzExMjVaMIGKMQswCQYDVQQGEwJDTjEyMDAGA1UECgwpQ2hpbmEg +SW50ZXJuZXQgTmV0d29yayBJbmZvcm1hdGlvbiBDZW50ZXIxRzBFBgNVBAMMPkNo +aW5hIEludGVybmV0IE5ldHdvcmsgSW5mb3JtYXRpb24gQ2VudGVyIEVWIENlcnRp +ZmljYXRlcyBSb290MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAm35z +7r07eKpkQ0H1UN+U8i6yjUqORlTSIRLIOTJCBumD1Z9S7eVnAztUwYyZmczpwA// +DdmEEbK40ctb3B75aDFk4Zv6dOtouSCV98YPjUesWgbdYavi7NifFy2cyjw1l1Vx +zUOFsUcW9SxTgHbP0wBkvUCZ3czY28Sf1hNfQYOL+Q2HklY0bBoQCxfVWhyXWIQ8 +hBouXJE0bhlffxdpxWXvayHG1VA6v2G5BY3vbzQ6sm8UY78WO5upKv23KzhmBsUs +4qpnHkWnjQRmQvaPK++IIGmPMowUc9orhpFjIpryp9vOiYurXccUwVswah+xt54u +gQEC7c+WXmPbqOY4twIDAQABo2MwYTAfBgNVHSMEGDAWgBR8cks5x8DbYqVPm6oY +NJKiyoOCWTAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4E +FgQUfHJLOcfA22KlT5uqGDSSosqDglkwDQYJKoZIhvcNAQEFBQADggEBACrDx0M3 +j92tpLIM7twUbY8opJhJywyA6vPtI2Z1fcXTIWd50XPFtQO3WKwMVC/GVhMPMdoG +52U7HW8228gd+f2ABsqjPWYWqJ1MFn3AlUa1UeTiH9fqBk1jjZaM7+czV0I664zB +echNdn3e9rG3geCg+aF4RhcaVpjwTj2rHO3sOdwHSPdj/gauwqRcalsyiMXHM4Ws +ZkJHwlgkmeHlPuV1LI5D1l08eB6olYIpUNHRFrrvwb562bTYzB5MRuF3sTGrvSrI +zo9uoV1/A3U05K2JRVRevq4opbs/eHnrc7MKDf2+yfdWrPa37S+bISnHOLaVxATy +wy39FCqQmbkHzJ8= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDqzCCApOgAwIBAgIRAMcoRwmzuGxFjB36JPU2TukwDQYJKoZIhvcNAQEFBQAw +PDEbMBkGA1UEAxMSQ29tU2lnbiBTZWN1cmVkIENBMRAwDgYDVQQKEwdDb21TaWdu +MQswCQYDVQQGEwJJTDAeFw0wNDAzMjQxMTM3MjBaFw0yOTAzMTYxNTA0NTZaMDwx +GzAZBgNVBAMTEkNvbVNpZ24gU2VjdXJlZCBDQTEQMA4GA1UEChMHQ29tU2lnbjEL +MAkGA1UEBhMCSUwwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDGtWhf +HZQVw6QIVS3joFd67+l0Kru5fFdJGhFeTymHDEjWaueP1H5XJLkGieQcPOqs49oh +gHMhCu95mGwfCP+hUH3ymBvJVG8+pSjsIQQPRbsHPaHA+iqYHU4Gk/v1iDurX8sW +v+bznkqH7Rnqwp9D5PGBpX8QTz7RSmKtUxvLg/8HZaWSLWapW7ha9B20IZFKF3ue +Mv5WJDmyVIRD9YTC2LxBkMyd1mja6YJQqTtoz7VdApRgFrFD2UNd3V2Hbuq7s8lr +9gOUCXDeFhF6K+h2j0kQmHe5Y1yLM5d19guMsqtb3nQgJT/j8xH5h2iGNXHDHYwt +6+UarA9z1YJZQIDTAgMBAAGjgacwgaQwDAYDVR0TBAUwAwEB/zBEBgNVHR8EPTA7 +MDmgN6A1hjNodHRwOi8vZmVkaXIuY29tc2lnbi5jby5pbC9jcmwvQ29tU2lnblNl +Y3VyZWRDQS5jcmwwDgYDVR0PAQH/BAQDAgGGMB8GA1UdIwQYMBaAFMFL7XC29z58 +ADsAj8c+DkWfHl3sMB0GA1UdDgQWBBTBS+1wtvc+fAA7AI/HPg5Fnx5d7DANBgkq +hkiG9w0BAQUFAAOCAQEAFs/ukhNQq3sUnjO2QiBq1BW9Cav8cujvR3qQrFHBZE7p +iL1DRYHjZiM/EoZNGeQFsOY3wo3aBijJD4mkU6l1P7CW+6tMM1X5eCZGbxs2mPtC +dsGCuY7e+0X5YxtiOzkGynd6qDwJz2w2PQ8KRUtpFhpFfTMDZflScZAmlaxMDPWL +kz/MdXSFmLr/YnpNH4n+rr2UAJm/EaXc4HnFFgt9AmEd6oX5AhVP51qJThRv4zdL +hfXBPGHg/QVBspJ/wx2g0K5SZGBrGMYmnNj1ZOQ2GmKfig8+/21OGVZOIJFsnzQz +OjRXUDpvgV4GxvU+fE6OK85lBi5d0ipTdF7Tbieejw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEMjCCAxqgAwIBAgIBATANBgkqhkiG9w0BAQUFADB7MQswCQYDVQQGEwJHQjEb +MBkGA1UECAwSR3JlYXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHDAdTYWxmb3JkMRow +GAYDVQQKDBFDb21vZG8gQ0EgTGltaXRlZDEhMB8GA1UEAwwYQUFBIENlcnRpZmlj +YXRlIFNlcnZpY2VzMB4XDTA0MDEwMTAwMDAwMFoXDTI4MTIzMTIzNTk1OVowezEL +MAkGA1UEBhMCR0IxGzAZBgNVBAgMEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UE +BwwHU2FsZm9yZDEaMBgGA1UECgwRQ29tb2RvIENBIExpbWl0ZWQxITAfBgNVBAMM +GEFBQSBDZXJ0aWZpY2F0ZSBTZXJ2aWNlczCCASIwDQYJKoZIhvcNAQEBBQADggEP +ADCCAQoCggEBAL5AnfRu4ep2hxxNRUSOvkbIgwadwSr+GB+O5AL686tdUIoWMQua +BtDFcCLNSS1UY8y2bmhGC1Pqy0wkwLxyTurxFa70VJoSCsN6sjNg4tqJVfMiWPPe +3M/vg4aijJRPn2jymJBGhCfHdr/jzDUsi14HZGWCwEiwqJH5YZ92IFCokcdmtet4 +YgNW8IoaE+oxox6gmf049vYnMlhvB/VruPsUK6+3qszWY19zjNoFmag4qMsXeDZR +rOme9Hg6jc8P2ULimAyrL58OAd7vn5lJ8S3frHRNG5i1R8XlKdH5kBjHYpy+g8cm +ez6KJcfA3Z3mNWgQIJ2P2N7Sw4ScDV7oL8kCAwEAAaOBwDCBvTAdBgNVHQ4EFgQU +oBEKIz6W8Qfs4q8p74Klf9AwpLQwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQF +MAMBAf8wewYDVR0fBHQwcjA4oDagNIYyaHR0cDovL2NybC5jb21vZG9jYS5jb20v +QUFBQ2VydGlmaWNhdGVTZXJ2aWNlcy5jcmwwNqA0oDKGMGh0dHA6Ly9jcmwuY29t +b2RvLm5ldC9BQUFDZXJ0aWZpY2F0ZVNlcnZpY2VzLmNybDANBgkqhkiG9w0BAQUF +AAOCAQEACFb8AvCb6P+k+tZ7xkSAzk/ExfYAWMymtrwUSWgEdujm7l3sAg9g1o1Q +GE8mTgHj5rCl7r+8dFRBv/38ErjHT1r0iWAFf2C3BUrz9vHCv8S5dIa2LX1rzNLz +Rt0vxuBqw8M0Ayx9lt1awg6nCpnBBYurDC/zXDrPbDdVCYfeU0BsWO/8tqtlbgT2 +G9w84FoVxp7Z8VlIMCFlA2zs6SFz7JsDoeA3raAVGI/6ugLOpyypEBMs1OUIJqsi +l2D4kF501KKaU73yqWjgom7C12yxow+ev+to51byrvLjKzg6CYG1a4XXvi3tPxq3 +smPi9WIsgtRqAEFQ8TmDn5XpNpaYbg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEPzCCAyegAwIBAgIBATANBgkqhkiG9w0BAQUFADB+MQswCQYDVQQGEwJHQjEb +MBkGA1UECAwSR3JlYXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHDAdTYWxmb3JkMRow +GAYDVQQKDBFDb21vZG8gQ0EgTGltaXRlZDEkMCIGA1UEAwwbU2VjdXJlIENlcnRp +ZmljYXRlIFNlcnZpY2VzMB4XDTA0MDEwMTAwMDAwMFoXDTI4MTIzMTIzNTk1OVow +fjELMAkGA1UEBhMCR0IxGzAZBgNVBAgMEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4G +A1UEBwwHU2FsZm9yZDEaMBgGA1UECgwRQ29tb2RvIENBIExpbWl0ZWQxJDAiBgNV +BAMMG1NlY3VyZSBDZXJ0aWZpY2F0ZSBTZXJ2aWNlczCCASIwDQYJKoZIhvcNAQEB +BQADggEPADCCAQoCggEBAMBxM4KK0HDrc4eCQNUd5MvJDkKQ+d40uaG6EfQlhfPM +cm3ye5drswfxdySRXyWP9nQ95IDC+DwN879A6vfIUtFyb+/Iq0G4bi4XKpVpDM3S +HpR7LZQdqnXXs5jLrLxkU0C8j6ysNstcrbvd4JQX7NFc0L/vpZXJkMWwrPsbQ996 +CF23uPJAGysnnlDOXmWCiIxe004MeuoIkbY2qitC++rCoznl2yY4rYsK7hljxxwk +3wN42ubqwUcaCwtGCd0C/N7Lh1/XMGNooa7cMqG6vv5Eq2i2pRcV/b3Vp6ea5EQz +6YiO/O1R65NxTq0B50SOqy3LqP4BSUjwwN3HaNiS/j0CAwEAAaOBxzCBxDAdBgNV +HQ4EFgQUPNiTiMLAggnMAZkGkyDpnnAJY08wDgYDVR0PAQH/BAQDAgEGMA8GA1Ud +EwEB/wQFMAMBAf8wgYEGA1UdHwR6MHgwO6A5oDeGNWh0dHA6Ly9jcmwuY29tb2Rv +Y2EuY29tL1NlY3VyZUNlcnRpZmljYXRlU2VydmljZXMuY3JsMDmgN6A1hjNodHRw +Oi8vY3JsLmNvbW9kby5uZXQvU2VjdXJlQ2VydGlmaWNhdGVTZXJ2aWNlcy5jcmww +DQYJKoZIhvcNAQEFBQADggEBAIcBbSMdflsXfcFhMs+P5/OKlFlm4J4oqF7Tt/Q0 +5qo5spcWxYJvMqTpjOev/e/C6LlLqqP05tqNZSH7uoDrJiiFGv45jN5bBAS0VPmj +Z55B+glSzAVIqMk/IQQezkhr/IXownuvf7fM+F86/TXGDe+X3EyrEeFryzHRbPtI +gKvcnDe4IRRLDXE97IMzbtFuMhbsmMcWi1mmNKsFVy2T96oTy9IT4rcuO81rUBcJ +aD61JlfutuC23bkpgHl9j6PwpCikFcSF9CfUa7/lXORlAnZUtOM3ZiTTGWHIUhDl +izeauan5Hb/qmZJhlv8BzaFfDbxxvA6sCx1HRR3B7Hzs/Sk= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEQzCCAyugAwIBAgIBATANBgkqhkiG9w0BAQUFADB/MQswCQYDVQQGEwJHQjEb +MBkGA1UECAwSR3JlYXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHDAdTYWxmb3JkMRow +GAYDVQQKDBFDb21vZG8gQ0EgTGltaXRlZDElMCMGA1UEAwwcVHJ1c3RlZCBDZXJ0 +aWZpY2F0ZSBTZXJ2aWNlczAeFw0wNDAxMDEwMDAwMDBaFw0yODEyMzEyMzU5NTla +MH8xCzAJBgNVBAYTAkdCMRswGQYDVQQIDBJHcmVhdGVyIE1hbmNoZXN0ZXIxEDAO +BgNVBAcMB1NhbGZvcmQxGjAYBgNVBAoMEUNvbW9kbyBDQSBMaW1pdGVkMSUwIwYD +VQQDDBxUcnVzdGVkIENlcnRpZmljYXRlIFNlcnZpY2VzMIIBIjANBgkqhkiG9w0B +AQEFAAOCAQ8AMIIBCgKCAQEA33FvNlhTWvI2VFeAxHQIIO0Yfyod5jWaHiWsnOWW +fnJSoBVC21ndZHoa0Lh73TkVvFVIxO06AOoxEbrycXQaZ7jPM8yoMa+j49d/vzMt +TGo87IvDktJTdyR0nAducPy9C1t2ul/y/9c3S0pgePfw+spwtOpZqqPOSC+pw7IL +fhdyFgymBwwbOM/JYrc/oJOlh0Hyt3BAd9i+FHzjqMB6juljatEPmsbS9Is6FARW +1O24zG71++IsWL1/T2sr92AkWCTOJu80kTrV44HQsvAEAtdbtz6SrGsSivnkBbA7 +kUlcsutT6vifR4buv5XAwAaf0lteERv0xwQ1KdJVXOTt6wIDAQABo4HJMIHGMB0G +A1UdDgQWBBTFe1i97doladL3WRaoszLAeydb9DAOBgNVHQ8BAf8EBAMCAQYwDwYD +VR0TAQH/BAUwAwEB/zCBgwYDVR0fBHwwejA8oDqgOIY2aHR0cDovL2NybC5jb21v +ZG9jYS5jb20vVHJ1c3RlZENlcnRpZmljYXRlU2VydmljZXMuY3JsMDqgOKA2hjRo +dHRwOi8vY3JsLmNvbW9kby5uZXQvVHJ1c3RlZENlcnRpZmljYXRlU2VydmljZXMu +Y3JsMA0GCSqGSIb3DQEBBQUAA4IBAQDIk4E7ibSvuIQSTI3S8NtwuleGFTQQuS9/ +HrCoiWChisJ3DFBKmwCL2Iv0QeLQg4pKHBQGsKNoBXAxMKdTmw7pSqBYaWcOrp32 +pSxBvzwGa+RZzG0Q8ZZvH9/0BAKkn0U+yNj6NkZEUD+Cl5EfKNsYEYwq5GWDVxIS +jBc/lDb+XbDABHcTuPQV1T84zJQ6VdCsmPW6AF/ghhmBeC8owH7TzEIK9a5QoNE+ +xqFx7D+gIIxmOom0jtTYsU0lR+4viMi14QVFwL4Ucd56/Y57fU0IlqUSc/Atyjcn +dBInTMu2l+nZrghtWjlA3QVHdWpaIbOjGM9O9y5Xt5hwXsjEeLBi +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDoTCCAomgAwIBAgILBAAAAAABD4WqLUgwDQYJKoZIhvcNAQEFBQAwOzEYMBYG +A1UEChMPQ3liZXJ0cnVzdCwgSW5jMR8wHQYDVQQDExZDeWJlcnRydXN0IEdsb2Jh +bCBSb290MB4XDTA2MTIxNTA4MDAwMFoXDTIxMTIxNTA4MDAwMFowOzEYMBYGA1UE +ChMPQ3liZXJ0cnVzdCwgSW5jMR8wHQYDVQQDExZDeWJlcnRydXN0IEdsb2JhbCBS +b290MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA+Mi8vRRQZhP/8NN5 +7CPytxrHjoXxEnOmGaoQ25yiZXRadz5RfVb23CO21O1fWLE3TdVJDm71aofW0ozS +J8bi/zafmGWgE07GKmSb1ZASzxQG9Dvj1Ci+6A74q05IlG2OlTEQXO2iLb3VOm2y +HLtgwEZLAfVJrn5GitB0jaEMAs7u/OePuGtm839EAL9mJRQr3RAwHQeWP032a7iP +t3sMpTjr3kfb1V05/Iin89cqdPHoWqI7n1C6poxFNcJQZZXcY4Lv3b93TZxiyWNz +FtApD0mpSPCzqrdsxacwOUBdrsTiXSZT8M4cIwhhqJQZugRiQOwfOHB3EgZxpzAY +XSUnpQIDAQABo4GlMIGiMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/ +MB0GA1UdDgQWBBS2CHsNesysIEyGVjJez6tuhS1wVzA/BgNVHR8EODA2MDSgMqAw +hi5odHRwOi8vd3d3Mi5wdWJsaWMtdHJ1c3QuY29tL2NybC9jdC9jdHJvb3QuY3Js +MB8GA1UdIwQYMBaAFLYIew16zKwgTIZWMl7Pq26FLXBXMA0GCSqGSIb3DQEBBQUA +A4IBAQBW7wojoFROlZfJ+InaRcHUowAl9B8Tq7ejhVhpwjCt2BWKLePJzYFa+HMj +Wqd8BfP9IjsO0QbE2zZMcwSO5bAi5MXzLqXZI+O4Tkogp24CJJ8iYGd7ix1yCcUx +XOl5n4BHPa2hCwcUPUf/A2kaDAtE52Mlp3+yybh2hO0j9n0Hq0V+09+zv+mKts2o +omcrUtW3ZfA5TGOgkXmTUg9U3YO7n9GPp1Nzw8v/MOx8BLjYRB+TX3EJIrduPuoc +A06dGiBh+4E37F78CkWr1+cXVdCg6mCbpvbjjFspwgZgFJ0tl0ypkxWdYcQBX0jW +WL1WMRJOEcgh4LMRkWXbtKaIOM5V +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEMzCCAxugAwIBAgIDCYPzMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNVBAYTAkRF +MRUwEwYDVQQKDAxELVRydXN0IEdtYkgxJzAlBgNVBAMMHkQtVFJVU1QgUm9vdCBD +bGFzcyAzIENBIDIgMjAwOTAeFw0wOTExMDUwODM1NThaFw0yOTExMDUwODM1NTha +ME0xCzAJBgNVBAYTAkRFMRUwEwYDVQQKDAxELVRydXN0IEdtYkgxJzAlBgNVBAMM +HkQtVFJVU1QgUm9vdCBDbGFzcyAzIENBIDIgMjAwOTCCASIwDQYJKoZIhvcNAQEB +BQADggEPADCCAQoCggEBANOySs96R+91myP6Oi/WUEWJNTrGa9v+2wBoqOADER03 +UAifTUpolDWzU9GUY6cgVq/eUXjsKj3zSEhQPgrfRlWLJ23DEE0NkVJD2IfgXU42 +tSHKXzlABF9bfsyjxiupQB7ZNoTWSPOSHjRGICTBpFGOShrvUD9pXRl/RcPHAY9R +ySPocq60vFYJfxLLHLGvKZAKyVXMD9O0Gu1HNVpK7ZxzBCHQqr0ME7UAyiZsxGsM +lFqVlNpQmvH/pStmMaTJOKDfHR+4CS7zp+hnUquVH+BGPtikw8paxTGA6Eian5Rp +/hnd2HN8gcqW3o7tszIFZYQ05ub9VxC1X3a/L7AQDcUCAwEAAaOCARowggEWMA8G +A1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFP3aFMSfMN4hvR5COfyrYyNJ4PGEMA4G +A1UdDwEB/wQEAwIBBjCB0wYDVR0fBIHLMIHIMIGAoH6gfIZ6bGRhcDovL2RpcmVj +dG9yeS5kLXRydXN0Lm5ldC9DTj1ELVRSVVNUJTIwUm9vdCUyMENsYXNzJTIwMyUy +MENBJTIwMiUyMDIwMDksTz1ELVRydXN0JTIwR21iSCxDPURFP2NlcnRpZmljYXRl +cmV2b2NhdGlvbmxpc3QwQ6BBoD+GPWh0dHA6Ly93d3cuZC10cnVzdC5uZXQvY3Js +L2QtdHJ1c3Rfcm9vdF9jbGFzc18zX2NhXzJfMjAwOS5jcmwwDQYJKoZIhvcNAQEL +BQADggEBAH+X2zDI36ScfSF6gHDOFBJpiBSVYEQBrLLpME+bUMJm2H6NMLVwMeni +acfzcNsgFYbQDfC+rAF1hM5+n02/t2A7nPPKHeJeaNijnZflQGDSNiH+0LS4F9p0 +o3/U37CYAqxva2ssJSRyoWXuJVrl5jLn8t+rSfrzkGkj2wTZ51xY/GXUl77M/C4K +zCUqNQT4YJEVdT1B/yMfGchs64JTBKbkTCJNjYy6zltz7GRUUG3RnFX7acM2w4y8 +PIWmawomDeCTmGCufsYkl4phX5GOZpIJhzbNi5stPvZR1FDUWSi9g/LMKHtThm3Y +Johw1+qRzT65ysCQblrGXnRl11z+o+I= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEQzCCAyugAwIBAgIDCYP0MA0GCSqGSIb3DQEBCwUAMFAxCzAJBgNVBAYTAkRF +MRUwEwYDVQQKDAxELVRydXN0IEdtYkgxKjAoBgNVBAMMIUQtVFJVU1QgUm9vdCBD +bGFzcyAzIENBIDIgRVYgMjAwOTAeFw0wOTExMDUwODUwNDZaFw0yOTExMDUwODUw +NDZaMFAxCzAJBgNVBAYTAkRFMRUwEwYDVQQKDAxELVRydXN0IEdtYkgxKjAoBgNV +BAMMIUQtVFJVU1QgUm9vdCBDbGFzcyAzIENBIDIgRVYgMjAwOTCCASIwDQYJKoZI +hvcNAQEBBQADggEPADCCAQoCggEBAJnxhDRwui+3MKCOvXwEz75ivJn9gpfSegpn +ljgJ9hBOlSJzmY3aFS3nBfwZcyK3jpgAvDw9rKFs+9Z5JUut8Mxk2og+KbgPCdM0 +3TP1YtHhzRnp7hhPTFiu4h7WDFsVWtg6uMQYZB7jM7K1iXdODL/ZlGsTl28So/6Z +qQTMFexgaDbtCHu39b+T7WYxg4zGcTSHThfqr4uRjRxWQa4iN1438h3Z0S0NL2lR +p75mpoo6Kr3HGrHhFPC+Oh25z1uxav60sUYgovseO3Dvk5h9jHOW8sXvhXCtKSb8 +HgQ+HKDYD8tSg2J87otTlZCpV6LqYQXY+U3EJ/pure3511H3a6UCAwEAAaOCASQw +ggEgMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFNOUikxiEyoZLsyvcop9Ntea +HNxnMA4GA1UdDwEB/wQEAwIBBjCB3QYDVR0fBIHVMIHSMIGHoIGEoIGBhn9sZGFw +Oi8vZGlyZWN0b3J5LmQtdHJ1c3QubmV0L0NOPUQtVFJVU1QlMjBSb290JTIwQ2xh +c3MlMjAzJTIwQ0ElMjAyJTIwRVYlMjAyMDA5LE89RC1UcnVzdCUyMEdtYkgsQz1E +RT9jZXJ0aWZpY2F0ZXJldm9jYXRpb25saXN0MEagRKBChkBodHRwOi8vd3d3LmQt +dHJ1c3QubmV0L2NybC9kLXRydXN0X3Jvb3RfY2xhc3NfM19jYV8yX2V2XzIwMDku +Y3JsMA0GCSqGSIb3DQEBCwUAA4IBAQA07XtaPKSUiO8aEXUHL7P+PPoeUSbrh/Yp +3uDx1MYkCenBz1UbtDDZzhr+BlGmFaQt77JLvyAoJUnRpjZ3NOhk31KxEcdzes05 +nsKtjHEh8lprr988TlWvsoRlFIm5d8sqMb7Po23Pb0iUMkZv53GMoKaEGTcH8gNF +CSuGdXzfX2lXANtu2KZyIktQ1HWYVt+3GP9DQ1CuekR78HlR10M9p9OB0/DJT7na +xpeG0ILD5EJt/rDiZE4OJudANCa1CInXCGNjOCd1HjPqbqjdn5lPdE2BiYBL3ZqX +KVwvvoFBuYz/6n1gBp7N1z3TLqMVvKjmJuVvw9y4AyHqnxbxLFS1 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIECTCCAvGgAwIBAgIQDV6ZCtadt3js2AdWO4YV2TANBgkqhkiG9w0BAQUFADBb +MQswCQYDVQQGEwJVUzEgMB4GA1UEChMXRGlnaXRhbCBTaWduYXR1cmUgVHJ1c3Qx +ETAPBgNVBAsTCERTVCBBQ0VTMRcwFQYDVQQDEw5EU1QgQUNFUyBDQSBYNjAeFw0w +MzExMjAyMTE5NThaFw0xNzExMjAyMTE5NThaMFsxCzAJBgNVBAYTAlVTMSAwHgYD +VQQKExdEaWdpdGFsIFNpZ25hdHVyZSBUcnVzdDERMA8GA1UECxMIRFNUIEFDRVMx +FzAVBgNVBAMTDkRTVCBBQ0VTIENBIFg2MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A +MIIBCgKCAQEAuT31LMmU3HWKlV1j6IR3dma5WZFcRt2SPp/5DgO0PWGSvSMmtWPu +ktKe1jzIDZBfZIGxqAgNTNj50wUoUrQBJcWVHAx+PhCEdc/BGZFjz+iokYi5Q1K7 +gLFViYsx+tC3dr5BPTCapCIlF3PoHuLTrCq9Wzgh1SpL11V94zpVvddtawJXa+ZH +fAjIgrrep4c9oW24MFbCswKBXy314powGCi4ZtPLAZZv6opFVdbgnf9nKxcCpk4a +ahELfrd755jWjHZvwTvbUJN+5dCOHze4vbrGn2zpfDPyMjwmR/onJALJfh1biEIT +ajV8fTXpLmaRcpPVMibEdPVTo7NdmvYJywIDAQABo4HIMIHFMA8GA1UdEwEB/wQF +MAMBAf8wDgYDVR0PAQH/BAQDAgHGMB8GA1UdEQQYMBaBFHBraS1vcHNAdHJ1c3Rk +c3QuY29tMGIGA1UdIARbMFkwVwYKYIZIAWUDAgEBATBJMEcGCCsGAQUFBwIBFjto +dHRwOi8vd3d3LnRydXN0ZHN0LmNvbS9jZXJ0aWZpY2F0ZXMvcG9saWN5L0FDRVMt +aW5kZXguaHRtbDAdBgNVHQ4EFgQUCXIGThhDD+XWzMNqizF7eI+og7gwDQYJKoZI +hvcNAQEFBQADggEBAKPYjtay284F5zLNAdMEA+V25FYrnJmQ6AgwbN99Pe7lv7Uk +QIRJ4dEorsTCOlMwiPH1d25Ryvr/ma8kXxug/fKshMrfqfBfBC6tFr8hlxCBPeP/ +h40y3JTlR4peahPJlJU90u7INJXQgNStMgiAVDzgvVJT11J8smk/f3rPanTK+gQq +nExaBqXpIK1FZg9p8d2/6eMyi/rgwYZNcjwu2JN4Cir42NInPRmJX1p7ijvMDNpR +rscL9yuwNwXsvFcj4jjSm2jzVhKIT0J8uDHEtdvkyCE06UgRNe76x5JXxZ805Mf2 +9w4LTJxoeHtxMcfrHuBnQfO3oKfN5XozNmr6mis= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDSjCCAjKgAwIBAgIQRK+wgNajJ7qJMDmGLvhAazANBgkqhkiG9w0BAQUFADA/ +MSQwIgYDVQQKExtEaWdpdGFsIFNpZ25hdHVyZSBUcnVzdCBDby4xFzAVBgNVBAMT +DkRTVCBSb290IENBIFgzMB4XDTAwMDkzMDIxMTIxOVoXDTIxMDkzMDE0MDExNVow +PzEkMCIGA1UEChMbRGlnaXRhbCBTaWduYXR1cmUgVHJ1c3QgQ28uMRcwFQYDVQQD +Ew5EU1QgUm9vdCBDQSBYMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +AN+v6ZdQCINXtMxiZfaQguzH0yxrMMpb7NnDfcdAwRgUi+DoM3ZJKuM/IUmTrE4O +rz5Iy2Xu/NMhD2XSKtkyj4zl93ewEnu1lcCJo6m67XMuegwGMoOifooUMM0RoOEq +OLl5CjH9UL2AZd+3UWODyOKIYepLYYHsUmu5ouJLGiifSKOeDNoJjj4XLh7dIN9b +xiqKqy69cK3FCxolkHRyxXtqqzTWMIn/5WgTe1QLyNau7Fqckh49ZLOMxt+/yUFw +7BZy1SbsOFU5Q9D8/RhcQPGX69Wam40dutolucbY38EVAjqr2m7xPi71XAicPNaD +aeQQmxkqtilX4+U9m5/wAl0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNV +HQ8BAf8EBAMCAQYwHQYDVR0OBBYEFMSnsaR7LHH62+FLkHX/xBVghYkQMA0GCSqG +SIb3DQEBBQUAA4IBAQCjGiybFwBcqR7uKGY3Or+Dxz9LwwmglSBd49lZRNI+DT69 +ikugdB/OEIKcdBodfpga3csTS7MgROSR6cz8faXbauX+5v3gTt23ADq1cEmv8uXr +AvHRAosZy5Q6XkjEGB5YGV8eAlrwDPGxrancWYaLbumR9YbK+rlmM6pZW87ipxZz +R8srzJmwN0jP41ZL9c8PDHIyh8bwRLtTcm1D9SZImlJnt1ir/md2cXjbDaJWFBM5 +JDGFoqgCWjBH4d1QB7wCCZAA62RjYJsWvIjJEubSfZGL+T0yjWW06XyxV3bqxbYo +Ob8VZRzI9neWagqNdwvYkQsEjgfbKbYK7p2CNTUQ +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDnzCCAoegAwIBAgIBJjANBgkqhkiG9w0BAQUFADBxMQswCQYDVQQGEwJERTEc +MBoGA1UEChMTRGV1dHNjaGUgVGVsZWtvbSBBRzEfMB0GA1UECxMWVC1UZWxlU2Vj +IFRydXN0IENlbnRlcjEjMCEGA1UEAxMaRGV1dHNjaGUgVGVsZWtvbSBSb290IENB +IDIwHhcNOTkwNzA5MTIxMTAwWhcNMTkwNzA5MjM1OTAwWjBxMQswCQYDVQQGEwJE +RTEcMBoGA1UEChMTRGV1dHNjaGUgVGVsZWtvbSBBRzEfMB0GA1UECxMWVC1UZWxl +U2VjIFRydXN0IENlbnRlcjEjMCEGA1UEAxMaRGV1dHNjaGUgVGVsZWtvbSBSb290 +IENBIDIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCrC6M14IspFLEU +ha88EOQ5bzVdSq7d6mGNlUn0b2SjGmBmpKlAIoTZ1KXleJMOaAGtuU1cOs7TuKhC +QN/Po7qCWWqSG6wcmtoIKyUn+WkjR/Hg6yx6m/UTAtB+NHzCnjwAWav12gz1Mjwr +rFDa1sPeg5TKqAyZMg4ISFZbavva4VhYAUlfckE8FQYBjl2tqriTtM2e66foai1S +NNs671x1Udrb8zH57nGYMsRUFUQM+ZtV7a3fGAigo4aKSe5TBY8ZTNXeWHmb0moc +QqvF1afPaA+W5OFhmHZhyJF81j4A4pFQh+GdCuatl9Idxjp9y7zaAzTVjlsB9WoH +txa2bkp/AgMBAAGjQjBAMB0GA1UdDgQWBBQxw3kbuvVT1xfgiXotF2wKsyudMzAP +BgNVHRMECDAGAQH/AgEFMA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQUFAAOC +AQEAlGRZrTlk5ynrE/5aw4sTV8gEJPB0d8Bg42f76Ymmg7+Wgnxu1MM9756Abrsp +tJh6sTtU6zkXR34ajgv8HzFZMQSyzhfzLMdiNlXiItiJVbSYSKpk+tYcNthEeFpa +IzpXl/V6ME+un2pMSyuOoAPjPuCp1NJ70rOo4nI8rZ7/gFnkm0W09juwzTkZmDLl +6iFhkOQxIY40sfcvNUqFENrnijchvllj4PKFiDFT1FQUhXB59C4Gdyd1Lx+4ivn+ +xbrYNuSD7Odlt79jWvNGr4GUN9RBjNYj1h7P9WgbRGOiWrqnNVmh5XAFmw4jV5mU +Cm26OWMohpLzGITY+9HPBVZkVw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDtzCCAp+gAwIBAgIQDOfg5RfYRv6P5WD8G/AwOTANBgkqhkiG9w0BAQUFADBl +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJv +b3QgQ0EwHhcNMDYxMTEwMDAwMDAwWhcNMzExMTEwMDAwMDAwWjBlMQswCQYDVQQG +EwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNl +cnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgQ0EwggEi +MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCtDhXO5EOAXLGH87dg+XESpa7c +JpSIqvTO9SA5KFhgDPiA2qkVlTJhPLWxKISKityfCgyDF3qPkKyK53lTXDGEKvYP +mDI2dsze3Tyoou9q+yHyUmHfnyDXH+Kx2f4YZNISW1/5WBg1vEfNoTb5a3/UsDg+ +wRvDjDPZ2C8Y/igPs6eD1sNuRMBhNZYW/lmci3Zt1/GiSw0r/wty2p5g0I6QNcZ4 +VYcgoc/lbQrISXwxmDNsIumH0DJaoroTghHtORedmTpyoeb6pNnVFzF1roV9Iq4/ +AUaG9ih5yLHa5FcXxH4cDrC0kqZWs72yl+2qp/C3xag/lRbQ/6GW6whfGHdPAgMB +AAGjYzBhMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW +BBRF66Kv9JLLgjEtUYunpyGd823IDzAfBgNVHSMEGDAWgBRF66Kv9JLLgjEtUYun +pyGd823IDzANBgkqhkiG9w0BAQUFAAOCAQEAog683+Lt8ONyc3pklL/3cmbYMuRC +dWKuh+vy1dneVrOfzM4UKLkNl2BcEkxY5NM9g0lFWJc1aRqoR+pWxnmrEthngYTf +fwk8lOa4JiwgvT2zKIn3X/8i4peEH+ll74fg38FnSbNd67IJKusm7Xi+fT8r87cm +NW1fiQG2SVufAQWbqz0lwcy2f8Lxb4bG+mRo64EtlOtCt/qMHt1i8b5QZ7dsvfPx +H2sMNgcWfzd8qVttevESRmCD1ycEvkvOl77DZypoEd+A5wwzZr8TDRRu838fYxAe ++o0bJW1sj6W3YQGx0qMmoRBxna3iw/nDmVG3KwcIzi7mULKn+gpFL6Lw8g== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDljCCAn6gAwIBAgIQC5McOtY5Z+pnI7/Dr5r0SzANBgkqhkiG9w0BAQsFADBl +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJv +b3QgRzIwHhcNMTMwODAxMTIwMDAwWhcNMzgwMTE1MTIwMDAwWjBlMQswCQYDVQQG +EwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNl +cnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgRzIwggEi +MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDZ5ygvUj82ckmIkzTz+GoeMVSA +n61UQbVH35ao1K+ALbkKz3X9iaV9JPrjIgwrvJUXCzO/GU1BBpAAvQxNEP4Htecc +biJVMWWXvdMX0h5i89vqbFCMP4QMls+3ywPgym2hFEwbid3tALBSfK+RbLE4E9Hp +EgjAALAcKxHad3A2m67OeYfcgnDmCXRwVWmvo2ifv922ebPynXApVfSr/5Vh88lA +bx3RvpO704gqu52/clpWcTs/1PPRCv4o76Pu2ZmvA9OPYLfykqGxvYmJHzDNw6Yu +YjOuFgJ3RFrngQo8p0Quebg/BLxcoIfhG69Rjs3sLPr4/m3wOnyqi+RnlTGNAgMB +AAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQW +BBTOw0q5mVXyuNtgv6l+vVa1lzan1jANBgkqhkiG9w0BAQsFAAOCAQEAyqVVjOPI +QW5pJ6d1Ee88hjZv0p3GeDgdaZaikmkuOGybfQTUiaWxMTeKySHMq2zNixya1r9I +0jJmwYrA8y8678Dj1JGG0VDjA9tzd29KOVPt3ibHtX2vK0LRdWLjSisCx1BL4Gni +lmwORGYQRI+tBev4eaymG+g3NJ1TyWGqolKvSnAWhsI6yLETcDbYz+70CjTVW0z9 +B5yiutkBclzzTcHdDrEcDcRjvq30FPuJ7KJBDkzMyFdA0G4Dqs0MjomZmWzwPDCv +ON9vvKO+KSAnq3T/EyJ43pdSVR6DtVQgA+6uwE9W3jfMw3+qBCe703e4YtsXfJwo +IhNzbM8m9Yop5w== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICRjCCAc2gAwIBAgIQC6Fa+h3foLVJRK/NJKBs7DAKBggqhkjOPQQDAzBlMQsw +CQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cu +ZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3Qg +RzMwHhcNMTMwODAxMTIwMDAwWhcNMzgwMTE1MTIwMDAwWjBlMQswCQYDVQQGEwJV +UzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNlcnQu +Y29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgRzMwdjAQBgcq +hkjOPQIBBgUrgQQAIgNiAAQZ57ysRGXtzbg/WPuNsVepRC0FFfLvC/8QdJ+1YlJf +Zn4f5dwbRXkLzMZTCp2NXQLZqVneAlr2lSoOjThKiknGvMYDOAdfVdp+CW7if17Q +RSAPWXYQ1qAk8C3eNvJsKTmjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/ +BAQDAgGGMB0GA1UdDgQWBBTL0L2p4ZgFUaFNN6KDec6NHSrkhDAKBggqhkjOPQQD +AwNnADBkAjAlpIFFAmsSS3V0T8gj43DydXLefInwz5FyYZ5eEJJZVrmDxxDnOOlY +JjZ91eQ0hjkCMHw2U/Aw5WJjOpnitqM7mzT6HtoQknFekROn3aRukswy1vUhZscv +6pZjamVFkpUBtA== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDrzCCApegAwIBAgIQCDvgVpBCRrGhdWrJWZHHSjANBgkqhkiG9w0BAQUFADBh +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBD +QTAeFw0wNjExMTAwMDAwMDBaFw0zMTExMTAwMDAwMDBaMGExCzAJBgNVBAYTAlVT +MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j +b20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IENBMIIBIjANBgkqhkiG +9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4jvhEXLeqKTTo1eqUKKPC3eQyaKl7hLOllsB +CSDMAZOnTjC3U/dDxGkAV53ijSLdhwZAAIEJzs4bg7/fzTtxRuLWZscFs3YnFo97 +nh6Vfe63SKMI2tavegw5BmV/Sl0fvBf4q77uKNd0f3p4mVmFaG5cIzJLv07A6Fpt +43C/dxC//AH2hdmoRBBYMql1GNXRor5H4idq9Joz+EkIYIvUX7Q6hL+hqkpMfT7P +T19sdl6gSzeRntwi5m3OFBqOasv+zbMUZBfHWymeMr/y7vrTC0LUq7dBMtoM1O/4 +gdW7jVg/tRvoSSiicNoxBN33shbyTApOB6jtSj1etX+jkMOvJwIDAQABo2MwYTAO +BgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA95QNVbR +TLtm8KPiGxvDl7I90VUwHwYDVR0jBBgwFoAUA95QNVbRTLtm8KPiGxvDl7I90VUw +DQYJKoZIhvcNAQEFBQADggEBAMucN6pIExIK+t1EnE9SsPTfrgT1eXkIoyQY/Esr +hMAtudXH/vTBH1jLuG2cenTnmCmrEbXjcKChzUyImZOMkXDiqw8cvpOp/2PV5Adg +06O/nVsJ8dWO41P0jmP6P6fbtGbfYmbW0W5BjfIttep3Sp+dWOIrWcBAI+0tKIJF +PnlUkiaY4IBIqDfv8NZ5YBberOgOzW6sRBc4L0na4UU+Krk2U886UAb3LujEV0ls +YSEY1QSteDwsOoBrp+uvFRTp2InBuThs4pFsiv9kuXclVzDAGySj4dzp30d8tbQk +CAUw7C29C79Fv1C5qfPrmAESrciIxpg0X40KPMbp1ZWVbd4= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDjjCCAnagAwIBAgIQAzrx5qcRqaC7KGSxHQn65TANBgkqhkiG9w0BAQsFADBh +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBH +MjAeFw0xMzA4MDExMjAwMDBaFw0zODAxMTUxMjAwMDBaMGExCzAJBgNVBAYTAlVT +MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j +b20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IEcyMIIBIjANBgkqhkiG +9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuzfNNNx7a8myaJCtSnX/RrohCgiN9RlUyfuI +2/Ou8jqJkTx65qsGGmvPrC3oXgkkRLpimn7Wo6h+4FR1IAWsULecYxpsMNzaHxmx +1x7e/dfgy5SDN67sH0NO3Xss0r0upS/kqbitOtSZpLYl6ZtrAGCSYP9PIUkY92eQ +q2EGnI/yuum06ZIya7XzV+hdG82MHauVBJVJ8zUtluNJbd134/tJS7SsVQepj5Wz +tCO7TG1F8PapspUwtP1MVYwnSlcUfIKdzXOS0xZKBgyMUNGPHgm+F6HmIcr9g+UQ +vIOlCsRnKPZzFBQ9RnbDhxSJITRNrw9FDKZJobq7nMWxM4MphQIDAQABo0IwQDAP +BgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAdBgNVHQ4EFgQUTiJUIBiV +5uNu5g/6+rkS7QYXjzkwDQYJKoZIhvcNAQELBQADggEBAGBnKJRvDkhj6zHd6mcY +1Yl9PMWLSn/pvtsrF9+wX3N3KjITOYFnQoQj8kVnNeyIv/iPsGEMNKSuIEyExtv4 +NeF22d+mQrvHRAiGfzZ0JFrabA0UWTW98kndth/Jsw1HKj2ZL7tcu7XUIOGZX1NG +Fdtom/DzMNU+MeKNhJ7jitralj41E6Vf8PlwUHBHQRFXGU7Aj64GxJUTFy8bJZ91 +8rGOmaFvE7FBcf6IKshPECBV1/MUReXgRPTqh5Uykw7+U0b6LJ3/iyK5S9kJRaTe +pLiaWN0bfVKfjllDiIGknibVb63dDcY3fe0Dkhvld1927jyNxF1WW6LZZm6zNTfl +MrY= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICPzCCAcWgAwIBAgIQBVVWvPJepDU1w6QP1atFcjAKBggqhkjOPQQDAzBhMQsw +CQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cu +ZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBHMzAe +Fw0xMzA4MDExMjAwMDBaFw0zODAxMTUxMjAwMDBaMGExCzAJBgNVBAYTAlVTMRUw +EwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5jb20x +IDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IEczMHYwEAYHKoZIzj0CAQYF +K4EEACIDYgAE3afZu4q4C/sLfyHS8L6+c/MzXRq8NOrexpu80JX28MzQC7phW1FG +fp4tn+6OYwwX7Adw9c+ELkCDnOg/QW07rdOkFFk2eJ0DQ+4QE2xy3q6Ip6FrtUPO +Z9wj/wMco+I+o0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAd +BgNVHQ4EFgQUs9tIpPmhxdiuNkHMEWNpYim8S8YwCgYIKoZIzj0EAwMDaAAwZQIx +AK288mw/EkrRLTnDCgmXc/SINoyIJ7vmiI1Qhadj+Z4y3maTD/HMsQmP3Wyr+mt/ +oAIwOWZbwmSNuJ5Q3KjVSaLtx9zRSX8XAbjIho9OjIgrqJqpisXRAL34VOKa5Vt8 +sycX +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDxTCCAq2gAwIBAgIQAqxcJmoLQJuPC3nyrkYldzANBgkqhkiG9w0BAQUFADBs +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSswKQYDVQQDEyJEaWdpQ2VydCBIaWdoIEFzc3VyYW5j +ZSBFViBSb290IENBMB4XDTA2MTExMDAwMDAwMFoXDTMxMTExMDAwMDAwMFowbDEL +MAkGA1UEBhMCVVMxFTATBgNVBAoTDERpZ2lDZXJ0IEluYzEZMBcGA1UECxMQd3d3 +LmRpZ2ljZXJ0LmNvbTErMCkGA1UEAxMiRGlnaUNlcnQgSGlnaCBBc3N1cmFuY2Ug +RVYgUm9vdCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMbM5XPm ++9S75S0tMqbf5YE/yc0lSbZxKsPVlDRnogocsF9ppkCxxLeyj9CYpKlBWTrT3JTW +PNt0OKRKzE0lgvdKpVMSOO7zSW1xkX5jtqumX8OkhPhPYlG++MXs2ziS4wblCJEM +xChBVfvLWokVfnHoNb9Ncgk9vjo4UFt3MRuNs8ckRZqnrG0AFFoEt7oT61EKmEFB +Ik5lYYeBQVCmeVyJ3hlKV9Uu5l0cUyx+mM0aBhakaHPQNAQTXKFx01p8VdteZOE3 +hzBWBOURtCmAEvF5OYiiAhF8J2a3iLd48soKqDirCmTCv2ZdlYTBoSUeh10aUAsg +EsxBu24LUTi4S8sCAwEAAaNjMGEwDgYDVR0PAQH/BAQDAgGGMA8GA1UdEwEB/wQF +MAMBAf8wHQYDVR0OBBYEFLE+w2kD+L9HAdSYJhoIAu9jZCvDMB8GA1UdIwQYMBaA +FLE+w2kD+L9HAdSYJhoIAu9jZCvDMA0GCSqGSIb3DQEBBQUAA4IBAQAcGgaX3Nec +nzyIZgYIVyHbIUf4KmeqvxgydkAQV8GK83rZEWWONfqe/EW1ntlMMUu4kehDLI6z +eM7b41N5cdblIZQB2lWHmiRk9opmzN6cN82oNLFpmyPInngiK3BD41VHMWEZ71jF +hS9OMPagMRYjyOfiZRYzy78aG6A9+MpeizGLYAiJLQwGXFK3xPkKmNEVX58Svnw2 +Yzi9RKR/5CYrCsSXaQ3pjOLAEFe4yHYSkVXySGnYvCoCWw9E1CAx2/S6cCZdkGCe +vEsXCS+0yx5DaMkHJ8HSXPfqIbloEpw8nL+e/IBcm2PN7EeqJSdnoDfzAIJ9VNep ++OkuE6N36B9K +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFkDCCA3igAwIBAgIQBZsbV56OITLiOQe9p3d1XDANBgkqhkiG9w0BAQwFADBi +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSEwHwYDVQQDExhEaWdpQ2VydCBUcnVzdGVkIFJvb3Qg +RzQwHhcNMTMwODAxMTIwMDAwWhcNMzgwMTE1MTIwMDAwWjBiMQswCQYDVQQGEwJV +UzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNlcnQu +Y29tMSEwHwYDVQQDExhEaWdpQ2VydCBUcnVzdGVkIFJvb3QgRzQwggIiMA0GCSqG +SIb3DQEBAQUAA4ICDwAwggIKAoICAQC/5pBzaN675F1KPDAiMGkz7MKnJS7JIT3y +ithZwuEppz1Yq3aaza57G4QNxDAf8xukOBbrVsaXbR2rsnnyyhHS5F/WBTxSD1If +xp4VpX6+n6lXFllVcq9ok3DCsrp1mWpzMpTREEQQLt+C8weE5nQ7bXHiLQwb7iDV +ySAdYyktzuxeTsiT+CFhmzTrBcZe7FsavOvJz82sNEBfsXpm7nfISKhmV1efVFiO +DCu3T6cw2Vbuyntd463JT17lNecxy9qTXtyOj4DatpGYQJB5w3jHtrHEtWoYOAMQ +jdjUN6QuBX2I9YI+EJFwq1WCQTLX2wRzKm6RAXwhTNS8rhsDdV14Ztk6MUSaM0C/ +CNdaSaTC5qmgZ92kJ7yhTzm1EVgX9yRcRo9k98FpiHaYdj1ZXUJ2h4mXaXpI8OCi +EhtmmnTK3kse5w5jrubU75KSOp493ADkRSWJtppEGSt+wJS00mFt6zPZxd9LBADM +fRyVw4/3IbKyEbe7f/LVjHAsQWCqsWMYRJUadmJ+9oCw++hkpjPRiQfhvbfmQ6QY +uKZ3AeEPlAwhHbJUKSWJbOUOUlFHdL4mrLZBdd56rF+NP8m800ERElvlEFDrMcXK +chYiCd98THU/Y+whX8QgUWtvsauGi0/C1kVfnSD8oR7FwI+isX4KJpn15GkvmB0t +9dmpsh3lGwIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB +hjAdBgNVHQ4EFgQU7NfjgtJxXWRM3y5nP+e6mK4cD08wDQYJKoZIhvcNAQEMBQAD +ggIBALth2X2pbL4XxJEbw6GiAI3jZGgPVs93rnD5/ZpKmbnJeFwMDF/k5hQpVgs2 +SV1EY+CtnJYYZhsjDT156W1r1lT40jzBQ0CuHVD1UvyQO7uYmWlrx8GnqGikJ9yd ++SeuMIW59mdNOj6PWTkiU0TryF0Dyu1Qen1iIQqAyHNm0aAFYF/opbSnr6j3bTWc +fFqK1qI4mfN4i/RN0iAL3gTujJtHgXINwBQy7zBZLq7gcfJW5GqXb5JQbZaNaHqa +sjYUegbyJLkJEVDXCLG4iXqEI2FCKeWjzaIgQdfRnGTZ6iahixTXTBmyUEFxPT9N +cCOGDErcgdLMMpSEDQgJlxxPwO5rIHQw0uA5NBCFIRUBCOhVMt5xSdkoF1BN5r5N +0XWs0Mr7QbhDparTwwVETyw2m+L64kW4I1NsBm9nVX9GtUw/bihaeSbSpKhil9Ie +4u1Ki7wb/UdKDd9nZn6yW0HQO+T0O/QEY+nvwlQAUaCKKsnOeMzV6ocEGLPOr0mI +r/OSmbaz5mEP0oUA51Aa5BuVnRmhuZyxm7EAHu/QD09CbMkKvO5D+jpxpchNJqU1 +/YldvIViHTLSoCtU7ZpXwdv6EM8Zt4tKG48BtieVU+i2iW1bvGjUI+iLUaJW+fCm +gKDWHrO8Dw9TdSmq6hN35N6MgSGtBxBHEa2HPQfRdbzP82Z+ +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIGSzCCBDOgAwIBAgIIamg+nFGby1MwDQYJKoZIhvcNAQELBQAwgbIxCzAJBgNV +BAYTAlRSMQ8wDQYDVQQHDAZBbmthcmExQDA+BgNVBAoMN0UtVHXEn3JhIEVCRyBC +aWxpxZ9pbSBUZWtub2xvamlsZXJpIHZlIEhpem1ldGxlcmkgQS7Fni4xJjAkBgNV +BAsMHUUtVHVncmEgU2VydGlmaWthc3lvbiBNZXJrZXppMSgwJgYDVQQDDB9FLVR1 +Z3JhIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTEzMDMwNTEyMDk0OFoXDTIz +MDMwMzEyMDk0OFowgbIxCzAJBgNVBAYTAlRSMQ8wDQYDVQQHDAZBbmthcmExQDA+ +BgNVBAoMN0UtVHXEn3JhIEVCRyBCaWxpxZ9pbSBUZWtub2xvamlsZXJpIHZlIEhp +em1ldGxlcmkgQS7Fni4xJjAkBgNVBAsMHUUtVHVncmEgU2VydGlmaWthc3lvbiBN +ZXJrZXppMSgwJgYDVQQDDB9FLVR1Z3JhIENlcnRpZmljYXRpb24gQXV0aG9yaXR5 +MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA4vU/kwVRHoViVF56C/UY +B4Oufq9899SKa6VjQzm5S/fDxmSJPZQuVIBSOTkHS0vdhQd2h8y/L5VMzH2nPbxH +D5hw+IyFHnSOkm0bQNGZDbt1bsipa5rAhDGvykPL6ys06I+XawGb1Q5KCKpbknSF +Q9OArqGIW66z6l7LFpp3RMih9lRozt6Plyu6W0ACDGQXwLWTzeHxE2bODHnv0ZEo +q1+gElIwcxmOj+GMB6LDu0rw6h8VqO4lzKRG+Bsi77MOQ7osJLjFLFzUHPhdZL3D +k14opz8n8Y4e0ypQBaNV2cvnOVPAmJ6MVGKLJrD3fY185MaeZkJVgkfnsliNZvcH +fC425lAcP9tDJMW/hkd5s3kc91r0E+xs+D/iWR+V7kI+ua2oMoVJl0b+SzGPWsut +dEcf6ZG33ygEIqDUD13ieU/qbIWGvaimzuT6w+Gzrt48Ue7LE3wBf4QOXVGUnhMM +ti6lTPk5cDZvlsouDERVxcr6XQKj39ZkjFqzAQqptQpHF//vkUAqjqFGOjGY5RH8 +zLtJVor8udBhmm9lbObDyz51Sf6Pp+KJxWfXnUYTTjF2OySznhFlhqt/7x3U+Lzn +rFpct1pHXFXOVbQicVtbC/DP3KBhZOqp12gKY6fgDT+gr9Oq0n7vUaDmUStVkhUX +U8u3Zg5mTPj5dUyQ5xJwx0UCAwEAAaNjMGEwHQYDVR0OBBYEFC7j27JJ0JxUeVz6 +Jyr+zE7S6E5UMA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAULuPbsknQnFR5 +XPonKv7MTtLoTlQwDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3DQEBCwUAA4ICAQAF +Nzr0TbdF4kV1JI+2d1LoHNgQk2Xz8lkGpD4eKexd0dCrfOAKkEh47U6YA5n+KGCR +HTAduGN8qOY1tfrTYXbm1gdLymmasoR6d5NFFxWfJNCYExL/u6Au/U5Mh/jOXKqY +GwXgAEZKgoClM4so3O0409/lPun++1ndYYRP0lSWE2ETPo+Aab6TR7U1Q9Jauz1c +77NCR807VRMGsAnb/WP2OogKmW9+4c4bU2pEZiNRCHu8W1Ki/QY3OEBhj0qWuJA3 ++GbHeJAAFS6LrVE1Uweoa2iu+U48BybNCAVwzDk/dr2l02cmAYamU9JgO3xDf1WK +vJUawSg5TB9D0pH0clmKuVb8P7Sd2nCcdlqMQ1DujjByTd//SffGqWfZbawCEeI6 +FiWnWAjLb1NBnEg4R2gz0dfHj9R0IdTDBZB6/86WiLEVKV0jq9BgoRJP3vQXzTLl +yb/IQ639Lo7xr+L0mPoSHyDYwKcMhcWQ9DstliaxLL5Mq+ux0orJ23gTDx4JnW2P +AJ8C2sH6H3p6CcRK5ogql5+Ji/03X186zjhZhkuvcQu02PJwT58yE+Owp1fl2tpD +y4Q08ijE6m30Ku/Ba3ba+367hTzSU8JNvnHhRdH9I2cNE3X7z2VnIp2usAnRCf8d +NL/+I5c30jn6PQ0GC7TbO6Orb1wdtn7os4I07QZcJA== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIF5zCCA8+gAwIBAgIITK9zQhyOdAIwDQYJKoZIhvcNAQEFBQAwgYAxODA2BgNV +BAMML0VCRyBFbGVrdHJvbmlrIFNlcnRpZmlrYSBIaXptZXQgU2HEn2xhecSxY8Sx +c8SxMTcwNQYDVQQKDC5FQkcgQmlsacWfaW0gVGVrbm9sb2ppbGVyaSB2ZSBIaXpt +ZXRsZXJpIEEuxZ4uMQswCQYDVQQGEwJUUjAeFw0wNjA4MTcwMDIxMDlaFw0xNjA4 +MTQwMDMxMDlaMIGAMTgwNgYDVQQDDC9FQkcgRWxla3Ryb25payBTZXJ0aWZpa2Eg +SGl6bWV0IFNhxJ9sYXnEsWPEsXPEsTE3MDUGA1UECgwuRUJHIEJpbGnFn2ltIFRl +a25vbG9qaWxlcmkgdmUgSGl6bWV0bGVyaSBBLsWeLjELMAkGA1UEBhMCVFIwggIi +MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDuoIRh0DpqZhAy2DE4f6en5f2h +4fuXd7hxlugTlkaDT7byX3JWbhNgpQGR4lvFzVcfd2NR/y8927k/qqk153nQ9dAk +tiHq6yOU/im/+4mRDGSaBUorzAzu8T2bgmmkTPiab+ci2hC6X5L8GCcKqKpE+i4s +tPtGmggDg3KriORqcsnlZR9uKg+ds+g75AxuetpX/dfreYteIAbTdgtsApWjluTL +dlHRKJ2hGvxEok3MenaoDT2/F08iiFD9rrbskFBKW5+VQarKD7JK/oCZTqNGFav4 +c0JqwmZ2sQomFd2TkuzbqV9UIlKRcF0T6kjsbgNs2d1s/OsNA/+mgxKb8amTD8Um +TDGyY5lhcucqZJnSuOl14nypqZoaqsNW2xCaPINStnuWt6yHd6i58mcLlEOzrz5z ++kI2sSXFCjEmN1ZnuqMLfdb3ic1nobc6HmZP9qBVFCVMLDMNpkGMvQQxahByCp0O +Lna9XvNRiYuoP1Vzv9s6xiQFlpJIqkuNKgPlV5EQ9GooFW5Hd4RcUXSfGenmHmMW +OeMRFeNYGkS9y8RsZteEBt8w9DeiQyJ50hBs37vmExH8nYQKE3vwO9D8owrXieqW +fo1IhR5kX9tUoqzVegJ5a9KK8GfaZXINFHDk6Y54jzJ0fFfy1tb0Nokb+Clsi7n2 +l9GkLqq+CxnCRelwXQIDAJ3Zo2MwYTAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB +/wQEAwIBBjAdBgNVHQ4EFgQU587GT/wWZ5b6SqMHwQSny2re2kcwHwYDVR0jBBgw +FoAU587GT/wWZ5b6SqMHwQSny2re2kcwDQYJKoZIhvcNAQEFBQADggIBAJuYml2+ +8ygjdsZs93/mQJ7ANtyVDR2tFcU22NU57/IeIl6zgrRdu0waypIN30ckHrMk2pGI +6YNw3ZPX6bqz3xZaPt7gyPvT/Wwp+BVGoGgmzJNSroIBk5DKd8pNSe/iWtkqvTDO +TLKBtjDOWU/aWR1qeqRFsIImgYZ29fUQALjuswnoT4cCB64kXPBfrAowzIpAoHME +wfuJJPaaHFy3PApnNgUIMbOv2AFoKuB4j3TeuFGkjGwgPaL7s9QJ/XvCgKqTbCmY +Iai7FvOpEl90tYeY8pUm3zTvilORiF0alKM/fCL414i6poyWqD1SNGKfAB5UVUJn +xk1Gj7sURT0KlhaOEKGXmdXTMIXM3rRyt7yKPBgpaP3ccQfuJDlq+u2lrDgv+R4Q +DgZxGhBM/nV+/x5XOULK1+EVoVZVWRvRo68R2E7DpSvvkL/A7IITW43WciyTTo9q +Kd+FPNMN4KIYEsxVL0e3p5sC/kH2iExt2qkBR4NkJ2IQgtYSe14DHzSpyZH+r11t +hie3I6p1GMog57AP14kOpmciY/SDQSsGS7tY1dHXt7kQY9iJSrSq3RZj9W6+YKH4 +7ejWkE8axsWgKdOnIaj1Wjz3x0miIZpKlVIglnKaZsv30oZDfCK+lvm9AahH3eU7 +QPl1K5srRmSGjR70j/sHd9DqSaIcjVIUpgqT +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFVjCCBD6gAwIBAgIQ7is969Qh3hSoYqwE893EATANBgkqhkiG9w0BAQUFADCB +8zELMAkGA1UEBhMCRVMxOzA5BgNVBAoTMkFnZW5jaWEgQ2F0YWxhbmEgZGUgQ2Vy +dGlmaWNhY2lvIChOSUYgUS0wODAxMTc2LUkpMSgwJgYDVQQLEx9TZXJ2ZWlzIFB1 +YmxpY3MgZGUgQ2VydGlmaWNhY2lvMTUwMwYDVQQLEyxWZWdldSBodHRwczovL3d3 +dy5jYXRjZXJ0Lm5ldC92ZXJhcnJlbCAoYykwMzE1MDMGA1UECxMsSmVyYXJxdWlh +IEVudGl0YXRzIGRlIENlcnRpZmljYWNpbyBDYXRhbGFuZXMxDzANBgNVBAMTBkVD +LUFDQzAeFw0wMzAxMDcyMzAwMDBaFw0zMTAxMDcyMjU5NTlaMIHzMQswCQYDVQQG +EwJFUzE7MDkGA1UEChMyQWdlbmNpYSBDYXRhbGFuYSBkZSBDZXJ0aWZpY2FjaW8g +KE5JRiBRLTA4MDExNzYtSSkxKDAmBgNVBAsTH1NlcnZlaXMgUHVibGljcyBkZSBD +ZXJ0aWZpY2FjaW8xNTAzBgNVBAsTLFZlZ2V1IGh0dHBzOi8vd3d3LmNhdGNlcnQu +bmV0L3ZlcmFycmVsIChjKTAzMTUwMwYDVQQLEyxKZXJhcnF1aWEgRW50aXRhdHMg +ZGUgQ2VydGlmaWNhY2lvIENhdGFsYW5lczEPMA0GA1UEAxMGRUMtQUNDMIIBIjAN +BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsyLHT+KXQpWIR4NA9h0X84NzJB5R +85iKw5K4/0CQBXCHYMkAqbWUZRkiFRfCQ2xmRJoNBD45b6VLeqpjt4pEndljkYRm +4CgPukLjbo73FCeTae6RDqNfDrHrZqJyTxIThmV6PttPB/SnCWDaOkKZx7J/sxaV +HMf5NLWUhdWZXqBIoH7nF2W4onW4HvPlQn2v7fOKSGRdghST2MDk/7NQcvJ29rNd +QlB50JQ+awwAvthrDk4q7D7SzIKiGGUzE3eeml0aE9jD2z3Il3rucO2n5nzbcc8t +lGLfbdb1OL4/pYUKGbio2Al1QnDE6u/LDsg0qBIimAy4E5S2S+zw0JDnJwIDAQAB +o4HjMIHgMB0GA1UdEQQWMBSBEmVjX2FjY0BjYXRjZXJ0Lm5ldDAPBgNVHRMBAf8E +BTADAQH/MA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUoMOLRKo3pUW/l4Ba0fF4 +opvpXY0wfwYDVR0gBHgwdjB0BgsrBgEEAfV4AQMBCjBlMCwGCCsGAQUFBwIBFiBo +dHRwczovL3d3dy5jYXRjZXJ0Lm5ldC92ZXJhcnJlbDA1BggrBgEFBQcCAjApGidW +ZWdldSBodHRwczovL3d3dy5jYXRjZXJ0Lm5ldC92ZXJhcnJlbCAwDQYJKoZIhvcN +AQEFBQADggEBAKBIW4IB9k1IuDlVNZyAelOZ1Vr/sXE7zDkJlF7W2u++AVtd0x7Y +/X1PzaBB4DSTv8vihpw3kpBWHNzrKQXlxJ7HNd+KDM3FIUPpqojlNcAZQmNaAl6k +SBg6hW/cnbw/nZzBh7h6YQjpdwt/cKt63dmXLGQehb+8dJahw3oS7AwaboMMPOhy +Rp/7SNVel+axofjk70YllJyJ22k4vuxcDlbHZVHlUIiIv0LVKz3l+bqeLrPK9HOS +Agu+TGbrIP65y7WZf+a2E/rKS03Z7lNGBjvGTq2TWoF+bCpLagVFjPIhpDGQh2xl +nJ2lYJU6Un/10asIbvPuW/mIPX64b24D5EI= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEAzCCAuugAwIBAgIQVID5oHPtPwBMyonY43HmSjANBgkqhkiG9w0BAQUFADB1 +MQswCQYDVQQGEwJFRTEiMCAGA1UECgwZQVMgU2VydGlmaXRzZWVyaW1pc2tlc2t1 +czEoMCYGA1UEAwwfRUUgQ2VydGlmaWNhdGlvbiBDZW50cmUgUm9vdCBDQTEYMBYG +CSqGSIb3DQEJARYJcGtpQHNrLmVlMCIYDzIwMTAxMDMwMTAxMDMwWhgPMjAzMDEy +MTcyMzU5NTlaMHUxCzAJBgNVBAYTAkVFMSIwIAYDVQQKDBlBUyBTZXJ0aWZpdHNl +ZXJpbWlza2Vza3VzMSgwJgYDVQQDDB9FRSBDZXJ0aWZpY2F0aW9uIENlbnRyZSBS +b290IENBMRgwFgYJKoZIhvcNAQkBFglwa2lAc2suZWUwggEiMA0GCSqGSIb3DQEB +AQUAA4IBDwAwggEKAoIBAQDIIMDs4MVLqwd4lfNE7vsLDP90jmG7sWLqI9iroWUy +euuOF0+W2Ap7kaJjbMeMTC55v6kF/GlclY1i+blw7cNRfdCT5mzrMEvhvH2/UpvO +bntl8jixwKIy72KyaOBhU8E2lf/slLo2rpwcpzIP5Xy0xm90/XsY6KxX7QYgSzIw +WFv9zajmofxwvI6Sc9uXp3whrj3B9UiHbCe9nyV0gVWw93X2PaRka9ZP585ArQ/d +MtO8ihJTmMmJ+xAdTX7Nfh9WDSFwhfYggx/2uh8Ej+p3iDXE/+pOoYtNP2MbRMNE +1CV2yreN1x5KZmTNXMWcg+HCCIia7E6j8T4cLNlsHaFLAgMBAAGjgYowgYcwDwYD +VR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFBLyWj7qVhy/ +zQas8fElyalL1BSZMEUGA1UdJQQ+MDwGCCsGAQUFBwMCBggrBgEFBQcDAQYIKwYB +BQUHAwMGCCsGAQUFBwMEBggrBgEFBQcDCAYIKwYBBQUHAwkwDQYJKoZIhvcNAQEF +BQADggEBAHv25MANqhlHt01Xo/6tu7Fq1Q+e2+RjxY6hUFaTlrg4wCQiZrxTFGGV +v9DHKpY5P30osxBAIWrEr7BSdxjhlthWXePdNl4dp1BUoMUq5KqMlIpPnTX/dqQG +E5Gion0ARD9V04I8GtVbvFZMIi5GQ4okQC3zErg7cBqklrkar4dBGmoYDQZPxz5u +uSlNDUmJEYcyW+ZLBMjkXOZ0c5RdFpgTlf7727FE5TpwrDdr5rMzcijJs1eg9gIW +iAYLtqZLICjU3j2LrTcFU3T+bsy8QxdxXvnFzBqpYe73dgzzcvRyrc9yAjYHR8/v +GVCJYMzpJJUPwssd8m92kMfMdcGWxZ0= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEKjCCAxKgAwIBAgIEOGPe+DANBgkqhkiG9w0BAQUFADCBtDEUMBIGA1UEChML +RW50cnVzdC5uZXQxQDA+BgNVBAsUN3d3dy5lbnRydXN0Lm5ldC9DUFNfMjA0OCBp +bmNvcnAuIGJ5IHJlZi4gKGxpbWl0cyBsaWFiLikxJTAjBgNVBAsTHChjKSAxOTk5 +IEVudHJ1c3QubmV0IExpbWl0ZWQxMzAxBgNVBAMTKkVudHJ1c3QubmV0IENlcnRp +ZmljYXRpb24gQXV0aG9yaXR5ICgyMDQ4KTAeFw05OTEyMjQxNzUwNTFaFw0yOTA3 +MjQxNDE1MTJaMIG0MRQwEgYDVQQKEwtFbnRydXN0Lm5ldDFAMD4GA1UECxQ3d3d3 +LmVudHJ1c3QubmV0L0NQU18yMDQ4IGluY29ycC4gYnkgcmVmLiAobGltaXRzIGxp +YWIuKTElMCMGA1UECxMcKGMpIDE5OTkgRW50cnVzdC5uZXQgTGltaXRlZDEzMDEG +A1UEAxMqRW50cnVzdC5uZXQgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgKDIwNDgp +MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArU1LqRKGsuqjIAcVFmQq +K0vRvwtKTY7tgHalZ7d4QMBzQshowNtTK91euHaYNZOLGp18EzoOH1u3Hs/lJBQe +sYGpjX24zGtLA/ECDNyrpUAkAH90lKGdCCmziAv1h3edVc3kw37XamSrhRSGlVuX +MlBvPci6Zgzj/L24ScF2iUkZ/cCovYmjZy/Gn7xxGWC4LeksyZB2ZnuU4q941mVT +XTzWnLLPKQP5L6RQstRIzgUyVYr9smRMDuSYB3Xbf9+5CFVghTAp+XtIpGmG4zU/ +HoZdenoVve8AjhUiVBcAkCaTvA5JaJG/+EfTnZVCwQ5N328mz8MYIWJmQ3DW1cAH +4QIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNV +HQ4EFgQUVeSB0RGAvtiJuQijMfmhJAkWuXAwDQYJKoZIhvcNAQEFBQADggEBADub +j1abMOdTmXx6eadNl9cZlZD7Bh/KM3xGY4+WZiT6QBshJ8rmcnPyT/4xmf3IDExo +U8aAghOY+rat2l098c5u9hURlIIM7j+VrxGrD9cv3h8Dj1csHsm7mhpElesYT6Yf +zX1XEC+bBAlahLVu2B064dae0Wx5XnkcFMXj0EyTO2U87d89vqbllRrDtRnDvV5b +u/8j72gZyxKTJ1wDLW8w0B62GqzeWvfRqqgnpv55gcR5mTNXuhKwqeBCbJPKVt7+ +bYQLCIt+jerXmCHG8+c8eS9enNFMFY3h7CI3zJpDC5fcgJCNs2ebb0gIFVbPv/Er +fF6adulZkMV8gzURZVE= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIE2DCCBEGgAwIBAgIEN0rSQzANBgkqhkiG9w0BAQUFADCBwzELMAkGA1UEBhMC +VVMxFDASBgNVBAoTC0VudHJ1c3QubmV0MTswOQYDVQQLEzJ3d3cuZW50cnVzdC5u +ZXQvQ1BTIGluY29ycC4gYnkgcmVmLiAobGltaXRzIGxpYWIuKTElMCMGA1UECxMc +KGMpIDE5OTkgRW50cnVzdC5uZXQgTGltaXRlZDE6MDgGA1UEAxMxRW50cnVzdC5u +ZXQgU2VjdXJlIFNlcnZlciBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw05OTA1 +MjUxNjA5NDBaFw0xOTA1MjUxNjM5NDBaMIHDMQswCQYDVQQGEwJVUzEUMBIGA1UE +ChMLRW50cnVzdC5uZXQxOzA5BgNVBAsTMnd3dy5lbnRydXN0Lm5ldC9DUFMgaW5j +b3JwLiBieSByZWYuIChsaW1pdHMgbGlhYi4pMSUwIwYDVQQLExwoYykgMTk5OSBF +bnRydXN0Lm5ldCBMaW1pdGVkMTowOAYDVQQDEzFFbnRydXN0Lm5ldCBTZWN1cmUg +U2VydmVyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIGdMA0GCSqGSIb3DQEBAQUA +A4GLADCBhwKBgQDNKIM0VBuJ8w+vN5Ex/68xYMmo6LIQaO2f55M28Qpku0f1BBc/ +I0dNxScZgSYMVHINiC3ZH5oSn7yzcdOAGT9HZnuMNSjSuQrfJNqc1lB5gXpa0zf3 +wkrYKZImZNHkmGw6AIr1NJtl+O3jEP/9uElY3KDegjlrgbEWGWG5VLbmQwIBA6OC +AdcwggHTMBEGCWCGSAGG+EIBAQQEAwIABzCCARkGA1UdHwSCARAwggEMMIHeoIHb +oIHYpIHVMIHSMQswCQYDVQQGEwJVUzEUMBIGA1UEChMLRW50cnVzdC5uZXQxOzA5 +BgNVBAsTMnd3dy5lbnRydXN0Lm5ldC9DUFMgaW5jb3JwLiBieSByZWYuIChsaW1p +dHMgbGlhYi4pMSUwIwYDVQQLExwoYykgMTk5OSBFbnRydXN0Lm5ldCBMaW1pdGVk +MTowOAYDVQQDEzFFbnRydXN0Lm5ldCBTZWN1cmUgU2VydmVyIENlcnRpZmljYXRp +b24gQXV0aG9yaXR5MQ0wCwYDVQQDEwRDUkwxMCmgJ6AlhiNodHRwOi8vd3d3LmVu +dHJ1c3QubmV0L0NSTC9uZXQxLmNybDArBgNVHRAEJDAigA8xOTk5MDUyNTE2MDk0 +MFqBDzIwMTkwNTI1MTYwOTQwWjALBgNVHQ8EBAMCAQYwHwYDVR0jBBgwFoAU8Bdi +E1U9s/8KAGv7UISX8+1i0BowHQYDVR0OBBYEFPAXYhNVPbP/CgBr+1CEl/PtYtAa +MAwGA1UdEwQFMAMBAf8wGQYJKoZIhvZ9B0EABAwwChsEVjQuMAMCBJAwDQYJKoZI +hvcNAQEFBQADgYEAkNwwAvpkdMKnCqV8IY00F6j7Rw7/JXyNEwr75Ji174z4xRAN +95K+8cPV1ZVqBLssziY2ZcgxxufuP+NXdYR6Ee9GTxj005i7qIcyunL2POI9n9cd +2cNgQ4xYDiKWL2KjLB+6rQXvqzJ4h6BUcxm1XAX5Uj5tLUUL9wqT6u0G+bI= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEkTCCA3mgAwIBAgIERWtQVDANBgkqhkiG9w0BAQUFADCBsDELMAkGA1UEBhMC +VVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xOTA3BgNVBAsTMHd3dy5lbnRydXN0 +Lm5ldC9DUFMgaXMgaW5jb3Jwb3JhdGVkIGJ5IHJlZmVyZW5jZTEfMB0GA1UECxMW +KGMpIDIwMDYgRW50cnVzdCwgSW5jLjEtMCsGA1UEAxMkRW50cnVzdCBSb290IENl +cnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA2MTEyNzIwMjM0MloXDTI2MTEyNzIw +NTM0MlowgbAxCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1FbnRydXN0LCBJbmMuMTkw +NwYDVQQLEzB3d3cuZW50cnVzdC5uZXQvQ1BTIGlzIGluY29ycG9yYXRlZCBieSBy +ZWZlcmVuY2UxHzAdBgNVBAsTFihjKSAyMDA2IEVudHJ1c3QsIEluYy4xLTArBgNV +BAMTJEVudHJ1c3QgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCCASIwDQYJ +KoZIhvcNAQEBBQADggEPADCCAQoCggEBALaVtkNC+sZtKm9I35RMOVcF7sN5EUFo +Nu3s/poBj6E4KPz3EEZmLk0eGrEaTsbRwJWIsMn/MYszA9u3g3s+IIRe7bJWKKf4 +4LlAcTfFy0cOlypowCKVYhXbR9n10Cv/gkvJrT7eTNuQgFA/CYqEAOwwCj0Yzfv9 +KlmaI5UXLEWeH25DeW0MXJj+SKfFI0dcXv1u5x609mhF0YaDW6KKjbHjKYD+JXGI +rb68j6xSlkuqUY3kEzEZ6E5Nn9uss2rVvDlUccp6en+Q3X0dgNmBu1kmwhH+5pPi +94DkZfs0Nw4pgHBNrziGLp5/V6+eF67rHMsoIV+2HNjnogQi+dPa2MsCAwEAAaOB +sDCBrTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zArBgNVHRAEJDAi +gA8yMDA2MTEyNzIwMjM0MlqBDzIwMjYxMTI3MjA1MzQyWjAfBgNVHSMEGDAWgBRo +kORnpKZTgMeGZqTx90tD+4S9bTAdBgNVHQ4EFgQUaJDkZ6SmU4DHhmak8fdLQ/uE +vW0wHQYJKoZIhvZ9B0EABBAwDhsIVjcuMTo0LjADAgSQMA0GCSqGSIb3DQEBBQUA +A4IBAQCT1DCw1wMgKtD5Y+iRDAUgqV8ZyntyTtSx29CW+1RaGSwMCPeyvIWonX9t +O1KzKtvn1ISMY/YPyyYBkVBs9F8U4pN0wBOeMDpQ47RgxRzwIkSNcUesyBrJ6Zua +AGAT/3B+XxFNSRuzFVJ7yVTav52Vr2ua2J7p8eRDjeIRRDq/r72DQnNSi6q7pynP +9WQcCk3RvKqsnyrQ/39/2n3qse0wJcGE2jTSW3iDVuycNsMm4hH2Z0kdkquM++v/ +eu6FSqdQgPCnXEqULl8FmTxSQeDNtGPPAUO6nIPcj2A781q0tHuu2guQOHXvgR1m +0vdXcDazv/wor3ElhVsT/h5/WrQ8 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIC+TCCAoCgAwIBAgINAKaLeSkAAAAAUNCR+TAKBggqhkjOPQQDAzCBvzELMAkG +A1UEBhMCVVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xKDAmBgNVBAsTH1NlZSB3 +d3cuZW50cnVzdC5uZXQvbGVnYWwtdGVybXMxOTA3BgNVBAsTMChjKSAyMDEyIEVu +dHJ1c3QsIEluYy4gLSBmb3IgYXV0aG9yaXplZCB1c2Ugb25seTEzMDEGA1UEAxMq +RW50cnVzdCBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IC0gRUMxMB4XDTEy +MTIxODE1MjUzNloXDTM3MTIxODE1NTUzNlowgb8xCzAJBgNVBAYTAlVTMRYwFAYD +VQQKEw1FbnRydXN0LCBJbmMuMSgwJgYDVQQLEx9TZWUgd3d3LmVudHJ1c3QubmV0 +L2xlZ2FsLXRlcm1zMTkwNwYDVQQLEzAoYykgMjAxMiBFbnRydXN0LCBJbmMuIC0g +Zm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxMzAxBgNVBAMTKkVudHJ1c3QgUm9vdCBD +ZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEVDMTB2MBAGByqGSM49AgEGBSuBBAAi +A2IABIQTydC6bUF74mzQ61VfZgIaJPRbiWlH47jCffHyAsWfoPZb1YsGGYZPUxBt +ByQnoaD41UcZYUx9ypMn6nQM72+WCf5j7HBdNq1nd67JnXxVRDqiY1Ef9eNi1KlH +Bz7MIKNCMEAwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0O +BBYEFLdj5xrdjekIplWDpOBqUEFlEUJJMAoGCCqGSM49BAMDA2cAMGQCMGF52OVC +R98crlOZF7ZvHH3hvxGU0QOIdeSNiaSKd0bebWHvAvX7td/M/k7//qnmpwIwW5nX +hTcGtXsI/esni0qU+eH6p44mCOh8kmhtc9hvJqwhAriZtyZBWyVgrtBIGu4G +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEPjCCAyagAwIBAgIESlOMKDANBgkqhkiG9w0BAQsFADCBvjELMAkGA1UEBhMC +VVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xKDAmBgNVBAsTH1NlZSB3d3cuZW50 +cnVzdC5uZXQvbGVnYWwtdGVybXMxOTA3BgNVBAsTMChjKSAyMDA5IEVudHJ1c3Qs +IEluYy4gLSBmb3IgYXV0aG9yaXplZCB1c2Ugb25seTEyMDAGA1UEAxMpRW50cnVz +dCBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IC0gRzIwHhcNMDkwNzA3MTcy +NTU0WhcNMzAxMjA3MTc1NTU0WjCBvjELMAkGA1UEBhMCVVMxFjAUBgNVBAoTDUVu +dHJ1c3QsIEluYy4xKDAmBgNVBAsTH1NlZSB3d3cuZW50cnVzdC5uZXQvbGVnYWwt +dGVybXMxOTA3BgNVBAsTMChjKSAyMDA5IEVudHJ1c3QsIEluYy4gLSBmb3IgYXV0 +aG9yaXplZCB1c2Ugb25seTEyMDAGA1UEAxMpRW50cnVzdCBSb290IENlcnRpZmlj +YXRpb24gQXV0aG9yaXR5IC0gRzIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK +AoIBAQC6hLZy254Ma+KZ6TABp3bqMriVQRrJ2mFOWHLP/vaCeb9zYQYKpSfYs1/T +RU4cctZOMvJyig/3gxnQaoCAAEUesMfnmr8SVycco2gvCoe9amsOXmXzHHfV1IWN +cCG0szLni6LVhjkCsbjSR87kyUnEO6fe+1R9V77w6G7CebI6C1XiUJgWMhNcL3hW +wcKUs/Ja5CeanyTXxuzQmyWC48zCxEXFjJd6BmsqEZ+pCm5IO2/b1BEZQvePB7/1 +U1+cPvQXLOZprE4yTGJ36rfo5bs0vBmLrpxR57d+tVOxMyLlbc9wPBr64ptntoP0 +jaWvYkxN4FisZDQSA/i2jZRjJKRxAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAP +BgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRqciZ60B7vfec7aVHUbI2fkBJmqzAN +BgkqhkiG9w0BAQsFAAOCAQEAeZ8dlsa2eT8ijYfThwMEYGprmi5ZiXMRrEPR9RP/ +jTkrwPK9T3CMqS/qF8QLVJ7UG5aYMzyorWKiAHarWWluBh1+xLlEjZivEtRh2woZ +Rkfz6/djwUAFQKXSt/S1mja/qYh2iARVBCuch38aNzx+LaUa2NSJXsq9rD1s2G2v +1fN2D807iDginWyTmsQ9v4IbZT+mD12q/OWyFcq1rca8PdCE6OoGcrBNOTJ4vz4R +nAuknZoh8/CbCzB428Hch0P+vGOaysXCHMnHjf87ElgI5rY97HosTvuDls4MPGmH +VHOkc8KT/1EQrBVUAdj8BbGJoX90g5pJ19xOe4pIb4tF9g== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDIDCCAomgAwIBAgIENd70zzANBgkqhkiG9w0BAQUFADBOMQswCQYDVQQGEwJV +UzEQMA4GA1UEChMHRXF1aWZheDEtMCsGA1UECxMkRXF1aWZheCBTZWN1cmUgQ2Vy +dGlmaWNhdGUgQXV0aG9yaXR5MB4XDTk4MDgyMjE2NDE1MVoXDTE4MDgyMjE2NDE1 +MVowTjELMAkGA1UEBhMCVVMxEDAOBgNVBAoTB0VxdWlmYXgxLTArBgNVBAsTJEVx +dWlmYXggU2VjdXJlIENlcnRpZmljYXRlIEF1dGhvcml0eTCBnzANBgkqhkiG9w0B +AQEFAAOBjQAwgYkCgYEAwV2xWGcIYu6gmi0fCG2RFGiYCh7+2gRvE4RiIcPRfM6f +BeC4AfBONOziipUEZKzxa1NfBbPLZ4C/QgKO/t0BCezhABRP/PvwDN1Dulsr4R+A +cJkVV5MW8Q+XarfCaCMczE1ZMKxRHjuvK9buY0V7xdlfUNLjUA86iOe/FP3gx7kC +AwEAAaOCAQkwggEFMHAGA1UdHwRpMGcwZaBjoGGkXzBdMQswCQYDVQQGEwJVUzEQ +MA4GA1UEChMHRXF1aWZheDEtMCsGA1UECxMkRXF1aWZheCBTZWN1cmUgQ2VydGlm +aWNhdGUgQXV0aG9yaXR5MQ0wCwYDVQQDEwRDUkwxMBoGA1UdEAQTMBGBDzIwMTgw +ODIyMTY0MTUxWjALBgNVHQ8EBAMCAQYwHwYDVR0jBBgwFoAUSOZo+SvSspXXR9gj +IBBPM5iQn9QwHQYDVR0OBBYEFEjmaPkr0rKV10fYIyAQTzOYkJ/UMAwGA1UdEwQF +MAMBAf8wGgYJKoZIhvZ9B0EABA0wCxsFVjMuMGMDAgbAMA0GCSqGSIb3DQEBBQUA +A4GBAFjOKer89961zgK5F7WF0bnj4JXMJTENAKaSbn+2kmOeUJXRmm/kEd5jhW6Y +7qj/WsjTVbJmcVfewCHrPSqnI0kBBIZCe/zuf6IWUrVnZ9NA2zsmWLIodz2uFHdh +1voqZiegDfqnc1zqcPGUIWVEX/r87yloqaKHee9570+sB3c4 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICkDCCAfmgAwIBAgIBATANBgkqhkiG9w0BAQQFADBaMQswCQYDVQQGEwJVUzEc +MBoGA1UEChMTRXF1aWZheCBTZWN1cmUgSW5jLjEtMCsGA1UEAxMkRXF1aWZheCBT +ZWN1cmUgR2xvYmFsIGVCdXNpbmVzcyBDQS0xMB4XDTk5MDYyMTA0MDAwMFoXDTIw +MDYyMTA0MDAwMFowWjELMAkGA1UEBhMCVVMxHDAaBgNVBAoTE0VxdWlmYXggU2Vj +dXJlIEluYy4xLTArBgNVBAMTJEVxdWlmYXggU2VjdXJlIEdsb2JhbCBlQnVzaW5l +c3MgQ0EtMTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAuucXkAJlsTRVPEnC +UdXfp9E3j9HngXNBUmCbnaEXJnitx7HoJpQytd4zjTov2/KaelpzmKNc6fuKcxtc +58O/gGzNqfTWK8D3+ZmqY6KxRwIP1ORROhI8bIpaVIRw28HFkM9yRcuoWcDNM50/ +o5brhTMhHD4ePmBudpxnhcXIw2ECAwEAAaNmMGQwEQYJYIZIAYb4QgEBBAQDAgAH +MA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAUvqigdHJQa0S3ySPY+6j/s1dr +aGwwHQYDVR0OBBYEFL6ooHRyUGtEt8kj2Puo/7NXa2hsMA0GCSqGSIb3DQEBBAUA +A4GBADDiAVGqx+pf2rnQZQ8w1j7aDRRJbpGTJxQx78T3LUX47Me/okENI7SS+RkA +Z70Br83gcfxaz2TE4JaY0KNA4gGK7ycH8WUBikQtBmV1UsCGECAhX2xrD2yuCRyv +8qIYNMR1pHMc8Y3c7635s3a0kr/clRAevsvIO1qEYBlWlKlV +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICgjCCAeugAwIBAgIBBDANBgkqhkiG9w0BAQQFADBTMQswCQYDVQQGEwJVUzEc +MBoGA1UEChMTRXF1aWZheCBTZWN1cmUgSW5jLjEmMCQGA1UEAxMdRXF1aWZheCBT +ZWN1cmUgZUJ1c2luZXNzIENBLTEwHhcNOTkwNjIxMDQwMDAwWhcNMjAwNjIxMDQw +MDAwWjBTMQswCQYDVQQGEwJVUzEcMBoGA1UEChMTRXF1aWZheCBTZWN1cmUgSW5j +LjEmMCQGA1UEAxMdRXF1aWZheCBTZWN1cmUgZUJ1c2luZXNzIENBLTEwgZ8wDQYJ +KoZIhvcNAQEBBQADgY0AMIGJAoGBAM4vGbwXt3fek6lfWg0XTzQaDJj0ItlZ1MRo +RvC0NcWFAyDGr0WlIVFFQesWWDYyb+JQYmT5/VGcqiTZ9J2DKocKIdMSODRsjQBu +WqDZQu4aIZX5UkxVWsUPOE9G+m34LjXWHXzr4vCwdYDIqROsvojvOm6rXyo4YgKw +Env+j6YDAgMBAAGjZjBkMBEGCWCGSAGG+EIBAQQEAwIABzAPBgNVHRMBAf8EBTAD +AQH/MB8GA1UdIwQYMBaAFEp4MlIR21kWNl7fwRQ2QGpHfEyhMB0GA1UdDgQWBBRK +eDJSEdtZFjZe38EUNkBqR3xMoTANBgkqhkiG9w0BAQQFAAOBgQB1W6ibAxHm6VZM +zfmpTMANmvPMZWnmJXbMWbfWVMMdzZmsGd20hdXgPfxiIKeES1hl8eL5lSE/9dR+ +WB5Hh1Q+WKG1tfgq73HnvMP2sUlG4tega+VWeponmHxGYhTnyfxuAxJ5gDgdSIKN +/Bf+KpYrtWKmpj29f5JZzVoqgrI3eQ== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICWjCCAcMCAgGlMA0GCSqGSIb3DQEBBAUAMHUxCzAJBgNVBAYTAlVTMRgwFgYD +VQQKEw9HVEUgQ29ycG9yYXRpb24xJzAlBgNVBAsTHkdURSBDeWJlclRydXN0IFNv +bHV0aW9ucywgSW5jLjEjMCEGA1UEAxMaR1RFIEN5YmVyVHJ1c3QgR2xvYmFsIFJv +b3QwHhcNOTgwODEzMDAyOTAwWhcNMTgwODEzMjM1OTAwWjB1MQswCQYDVQQGEwJV +UzEYMBYGA1UEChMPR1RFIENvcnBvcmF0aW9uMScwJQYDVQQLEx5HVEUgQ3liZXJU +cnVzdCBTb2x1dGlvbnMsIEluYy4xIzAhBgNVBAMTGkdURSBDeWJlclRydXN0IEds +b2JhbCBSb290MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCVD6C28FCc6HrH +iM3dFw4usJTQGz0O9pTAipTHBsiQl8i4ZBp6fmw8U+E3KHNgf7KXUwefU/ltWJTS +r41tiGeA5u2ylc9yMcqlHHK6XALnZELn+aks1joNrI1CqiQBOeacPwGFVw1Yh0X4 +04Wqk2kmhXBIgD8SFcd5tB8FLztimQIDAQABMA0GCSqGSIb3DQEBBAUAA4GBAG3r +GwnpXtlR22ciYaQqPEh346B8pt5zohQDhT37qw4wxYMWM4ETCJ57NE7fQMh017l9 +3PR2VX2bY1QY6fDq81yx2YtCHrnAlU66+tXifPVoYb+O7AWXX1uw16OFNMQkpw0P +lZPvy5TYnh+dXIVtx6quTx8itc2VrbqnzPmrC3p/ +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDVDCCAjygAwIBAgIDAjRWMA0GCSqGSIb3DQEBBQUAMEIxCzAJBgNVBAYTAlVT +MRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMRswGQYDVQQDExJHZW9UcnVzdCBHbG9i +YWwgQ0EwHhcNMDIwNTIxMDQwMDAwWhcNMjIwNTIxMDQwMDAwWjBCMQswCQYDVQQG +EwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEbMBkGA1UEAxMSR2VvVHJ1c3Qg +R2xvYmFsIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2swYYzD9 +9BcjGlZ+W988bDjkcbd4kdS8odhM+KhDtgPpTSEHCIjaWC9mOSm9BXiLnTjoBbdq +fnGk5sRgprDvgOSJKA+eJdbtg/OtppHHmMlCGDUUna2YRpIuT8rxh0PBFpVXLVDv +iS2Aelet8u5fa9IAjbkU+BQVNdnARqN7csiRv8lVK83Qlz6cJmTM386DGXHKTubU +1XupGc1V3sjs0l44U+VcT4wt/lAjNvxm5suOpDkZALeVAjmRCw7+OC7RHQWa9k0+ +bw8HHa8sHo9gOeL6NlMTOdReJivbPagUvTLrGAMoUgRx5aszPeE4uwc2hGKceeoW +MPRfwCvocWvk+QIDAQABo1MwUTAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTA +ephojYn7qwVkDBF9qn1luMrMTjAfBgNVHSMEGDAWgBTAephojYn7qwVkDBF9qn1l +uMrMTjANBgkqhkiG9w0BAQUFAAOCAQEANeMpauUvXVSOKVCUn5kaFOSPeCpilKIn +Z57QzxpeR+nBsqTP3UEaBU6bS+5Kb1VSsyShNwrrZHYqLizz/Tt1kL/6cdjHPTfS +tQWVYrmm3ok9Nns4d0iXrKYgjy6myQzCsplFAMfOEVEiIuCl6rYVSAlk6l5PdPcF +PseKUgzbFbS9bZvlxrFUaKnjaZC2mqUPuLk/IH2uSrW4nOQdtqvmlKXBx4Ot2/Un +hw4EbNX/3aBd7YdStysVAq45pmp06drE57xNNB6pXE0zX5IJL4hmXXeXxx12E6nV +5fEWCRE11azbJHFwLJhWC9kXtNHjUStedejV0NxPNO3CBWaAocvmMw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDZjCCAk6gAwIBAgIBATANBgkqhkiG9w0BAQUFADBEMQswCQYDVQQGEwJVUzEW +MBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEdMBsGA1UEAxMUR2VvVHJ1c3QgR2xvYmFs +IENBIDIwHhcNMDQwMzA0MDUwMDAwWhcNMTkwMzA0MDUwMDAwWjBEMQswCQYDVQQG +EwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEdMBsGA1UEAxMUR2VvVHJ1c3Qg +R2xvYmFsIENBIDIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDvPE1A +PRDfO1MA4Wf+lGAVPoWI8YkNkMgoI5kF6CsgncbzYEbYwbLVjDHZ3CB5JIG/NTL8 +Y2nbsSpr7iFY8gjpeMtvy/wWUsiRxP89c96xPqfCfWbB9X5SJBri1WeR0IIQ13hL +TytCOb1kLUCgsBDTOEhGiKEMuzozKmKY+wCdE1l/bztyqu6mD4b5BWHqZ38MN5aL +5mkWRxHCJ1kDs6ZgwiFAVvqgx306E+PsV8ez1q6diYD3Aecs9pYrEw15LNnA5IZ7 +S4wMcoKK+xfNAGw6EzywhIdLFnopsk/bHdQL82Y3vdj2V7teJHq4PIu5+pIaGoSe +2HSPqht/XvT+RSIhAgMBAAGjYzBhMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYE +FHE4NvICMVNHK266ZUapEBVYIAUJMB8GA1UdIwQYMBaAFHE4NvICMVNHK266ZUap +EBVYIAUJMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQUFAAOCAQEAA/e1K6td +EPx7srJerJsOflN4WT5CBP51o62sgU7XAotexC3IUnbHLB/8gTKY0UvGkpMzNTEv +/NgdRN3ggX+d6YvhZJFiCzkIjKx0nVnZellSlxG5FntvRdOW2TF9AjYPnDtuzywN +A0ZF66D0f0hExghAzN4bcLUprbqLOzRldRtxIR0sFAqwlpW41uryZfspuk/qkZN0 +abby/+Ea0AzRdoXLiiW9l14sbxWZJue2Kf8i7MkCx1YAzUm5s2x7UwQa4qjJqhIF +I8LO57sEAszAR6LkxCkvW0VXiVHuPOtSCP8HNR6fNWpHSlaY0VqFH4z1Ir+rzoPz +4iIprn2DQKi6bA== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDfDCCAmSgAwIBAgIQGKy1av1pthU6Y2yv2vrEoTANBgkqhkiG9w0BAQUFADBY +MQswCQYDVQQGEwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjExMC8GA1UEAxMo +R2VvVHJ1c3QgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0wNjEx +MjcwMDAwMDBaFw0zNjA3MTYyMzU5NTlaMFgxCzAJBgNVBAYTAlVTMRYwFAYDVQQK +Ew1HZW9UcnVzdCBJbmMuMTEwLwYDVQQDEyhHZW9UcnVzdCBQcmltYXJ5IENlcnRp +ZmljYXRpb24gQXV0aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEAvrgVe//UfH1nrYNke8hCUy3f9oQIIGHWAVlqnEQRr+92/ZV+zmEwu3qDXwK9 +AWbK7hWNb6EwnL2hhZ6UOvNWiAAxz9juapYC2e0DjPt1befquFUWBRaa9OBesYjA +ZIVcFU2Ix7e64HXprQU9nceJSOC7KMgD4TCTZF5SwFlwIjVXiIrxlQqD17wxcwE0 +7e9GceBrAqg1cmuXm2bgyxx5X9gaBGgeRwLmnWDiNpcB3841kt++Z8dtd1k7j53W +kBWUvEI0EME5+bEnPn7WinXFsq+W06Lem+SYvn3h6YGttm/81w7a4DSwDRp35+MI +mO9Y+pyEtzavwt+s0vQQBnBxNQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4G +A1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQULNVQQZcVi/CPNmFbSvtr2ZnJM5IwDQYJ +KoZIhvcNAQEFBQADggEBAFpwfyzdtzRP9YZRqSa+S7iq8XEN3GHHoOo0Hnp3DwQ1 +6CePbJC/kRYkRj5KTs4rFtULUh38H2eiAkUxT87z+gOneZ1TatnaYzr4gNfTmeGl +4b7UVXGYNTq+k+qurUKykG/g/CFNNWMziUnWm07Kx+dOCQD32sfvmWKZd7aVIl6K +oKv0uHiYyjgZmclynnjNS6yvGaBzEi38wkG6gZHaFloxt/m0cYASSJlyc1pZU8Fj +UjPtp8nSOQJw+uCxQmYpqptR7TBUIhRf2asdweSU8Pj1K/fqynhG1riR/aYNKxoU +AT6A8EKglQdebc3MS6RFjasS6LPeWuWgfOgPIh1a6Vk= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICrjCCAjWgAwIBAgIQPLL0SAoA4v7rJDteYD7DazAKBggqhkjOPQQDAzCBmDEL +MAkGA1UEBhMCVVMxFjAUBgNVBAoTDUdlb1RydXN0IEluYy4xOTA3BgNVBAsTMChj +KSAyMDA3IEdlb1RydXN0IEluYy4gLSBGb3IgYXV0aG9yaXplZCB1c2Ugb25seTE2 +MDQGA1UEAxMtR2VvVHJ1c3QgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0 +eSAtIEcyMB4XDTA3MTEwNTAwMDAwMFoXDTM4MDExODIzNTk1OVowgZgxCzAJBgNV +BAYTAlVTMRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMTkwNwYDVQQLEzAoYykgMjAw +NyBHZW9UcnVzdCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxNjA0BgNV +BAMTLUdlb1RydXN0IFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgLSBH +MjB2MBAGByqGSM49AgEGBSuBBAAiA2IABBWx6P0DFUPlrOuHNxFi79KDNlJ9RVcL +So17VDs6bl8VAsBQps8lL33KSLjHUGMcKiEIfJo22Av+0SbFWDEwKCXzXV2juLal +tJLtbCyf691DiaI8S0iRHVDsJt/WYC69IaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFBVfNVdRVfslsq0DafwBo/q+EVXVMAoG +CCqGSM49BAMDA2cAMGQCMGSWWaboCd6LuvpaiIjwH5HTRqjySkwCY/tsXzjbLkGT +qQ7mndwxHLKgpxgceeHHNgIwOlavmnRs9vuD4DPTCF+hnMJbn0bWtsuRBmOiBucz +rD6ogRLQy7rQkgu2npaqBA+K +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIID/jCCAuagAwIBAgIQFaxulBmyeUtB9iepwxgPHzANBgkqhkiG9w0BAQsFADCB +mDELMAkGA1UEBhMCVVMxFjAUBgNVBAoTDUdlb1RydXN0IEluYy4xOTA3BgNVBAsT +MChjKSAyMDA4IEdlb1RydXN0IEluYy4gLSBGb3IgYXV0aG9yaXplZCB1c2Ugb25s +eTE2MDQGA1UEAxMtR2VvVHJ1c3QgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhv +cml0eSAtIEczMB4XDTA4MDQwMjAwMDAwMFoXDTM3MTIwMTIzNTk1OVowgZgxCzAJ +BgNVBAYTAlVTMRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMTkwNwYDVQQLEzAoYykg +MjAwOCBHZW9UcnVzdCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxNjA0 +BgNVBAMTLUdlb1RydXN0IFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkg +LSBHMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANziXmJYHTNXOTIz ++uvLh4yn1ErdBojqZI4xmKU4kB6Yzy5jK/BGvESyiaHAKAxJcCGVn2TAppMSAmUm +hsalifD614SgcK9PGpc/BkTVyetyEH3kMSj7HGHmKAdEc5IiaacDiGydY8hS2pgn +5whMcD60yRLBxWeDXTPzAxHsatBT4tG6NmCUgLthY2xbF37fQJQeqw3CIShwiP/W +JmxsYAQlTlV+fe+/lEjetx3dcI0FX4ilm/LC7urRQEFtYjgdVgbFA0dRIBn8exAL +DmKudlW/X3e+PkkBUz2YJQN2JFodtNuJ6nnltrM7P7pMKEF/BqxqjsHQ9gUdfeZC +huOl1UcCAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYw +HQYDVR0OBBYEFMR5yo6hTgMdHNxr2zFblD4/MH8tMA0GCSqGSIb3DQEBCwUAA4IB +AQAtxRPPVoB7eni9n64smefv2t+UXglpp+duaIy9cr5HqQ6XErhK8WTTOd8lNNTB +zU6B8A8ExCSzNJbGpqow32hhc9f5joWJ7w5elShKKiePEI4ufIbEAp7aDHdlDkQN +kv39sxY2+hENHYwOB4lqKVb3cvTdFZx3NWZXqxNT2I7BQMXXExZacse3aQHEerGD +AWh9jUGhlBjBJVz88P6DAod8DQ3PLghcSkANPuyBYeYk28rgDi0Hsj5W3I31QYUH +SJsMC8tJP33st/3LjWeJGqvtux6jAAgIFyqCXDFdRootD4abdNlF+9RAsXqqaC2G +spki4cErx5z481+oghLrGREt +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFaDCCA1CgAwIBAgIBATANBgkqhkiG9w0BAQUFADBFMQswCQYDVQQGEwJVUzEW +MBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEeMBwGA1UEAxMVR2VvVHJ1c3QgVW5pdmVy +c2FsIENBMB4XDTA0MDMwNDA1MDAwMFoXDTI5MDMwNDA1MDAwMFowRTELMAkGA1UE +BhMCVVMxFjAUBgNVBAoTDUdlb1RydXN0IEluYy4xHjAcBgNVBAMTFUdlb1RydXN0 +IFVuaXZlcnNhbCBDQTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAKYV +VaCjxuAfjJ0hUNfBvitbtaSeodlyWL0AG0y/YckUHUWCq8YdgNY96xCcOq9tJPi8 +cQGeBvV8Xx7BDlXKg5pZMK4ZyzBIle0iN430SppyZj6tlcDgFgDgEB8rMQ7XlFTT +QjOgNB0eRXbdT8oYN+yFFXoZCPzVx5zw8qkuEKmS5j1YPakWaDwvdSEYfyh3peFh +F7em6fgemdtzbvQKoiFs7tqqhZJmr/Z6a4LauiIINQ/PQvE1+mrufislzDoR5G2v +c7J2Ha3QsnhnGqQ5HFELZ1aD/ThdDc7d8Lsrlh/eezJS/R27tQahsiFepdaVaH/w +mZ7cRQg+59IJDTWU3YBOU5fXtQlEIGQWFwMCTFMNaN7VqnJNk22CDtucvc+081xd +VHppCZbW2xHBjXWotM85yM48vCR85mLK4b19p71XZQvk/iXttmkQ3CgaRr0BHdCX +teGYO8A3ZNY9lO4L4fUorgtWv3GLIylBjobFS1J72HGrH4oVpjuDWtdYAVHGTEHZ +f9hBZ3KiKN9gg6meyHv8U3NyWfWTehd2Ds735VzZC1U0oqpbtWpU5xPKV+yXbfRe +Bi9Fi1jUIxaS5BZuKGNZMN9QAZxjiRqf2xeUgnA3wySemkfWWspOqGmJch+RbNt+ +nhutxx9z3SxPGWX9f5NAEC7S8O08ni4oPmkmM8V7AgMBAAGjYzBhMA8GA1UdEwEB +/wQFMAMBAf8wHQYDVR0OBBYEFNq7LqqwDLiIJlF0XG0D08DYj3rWMB8GA1UdIwQY +MBaAFNq7LqqwDLiIJlF0XG0D08DYj3rWMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG +9w0BAQUFAAOCAgEAMXjmx7XfuJRAyXHEqDXsRh3ChfMoWIawC/yOsjmPRFWrZIRc +aanQmjg8+uUfNeVE44B5lGiku8SfPeE0zTBGi1QrlaXv9z+ZhP015s8xxtxqv6fX +IwjhmF7DWgh2qaavdy+3YL1ERmrvl/9zlcGO6JP7/TG37FcREUWbMPEaiDnBTzyn +ANXH/KttgCJwpQzgXQQpAvvLoJHRfNbDflDVnVi+QTjruXU8FdmbyUqDWcDaU/0z +uzYYm4UPFd3uLax2k7nZAY1IEKj79TiG8dsKxr2EoyNB3tZ3b4XUhRxQ4K5RirqN +Pnbiucon8l+f725ZDQbYKxek0nxru18UGkiPGkzns0ccjkxFKyDuSN/n3QmOGKja +QI2SJhFTYXNd673nxE0pN2HrrDktZy4W1vUAg4WhzH92xH3kt0tm7wNFYGm2DFKW +koRepqO1pD4r2czYG0eq8kTaT/kD6PAUyz/zg97QwVTjt+gKN02LIFkDMBmhLMi9 +ER/frslKxfMnZmaGrGiR/9nmUxwPi1xpZQomyB40w11Re9epnAahNt3ViZS82eQt +DF4JbAiXfKM9fJP/P6EUp8+1Xevb2xzEdt+Iub1FBZUbrvxGakyvSOPOrg/Sfuvm +bJxPgWp6ZKy7PtXny3YuxadIwVyQD8vIP/rmMuGNG2+k5o7Y+SlIis5z/iw= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFbDCCA1SgAwIBAgIBATANBgkqhkiG9w0BAQUFADBHMQswCQYDVQQGEwJVUzEW +MBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEgMB4GA1UEAxMXR2VvVHJ1c3QgVW5pdmVy +c2FsIENBIDIwHhcNMDQwMzA0MDUwMDAwWhcNMjkwMzA0MDUwMDAwWjBHMQswCQYD +VQQGEwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEgMB4GA1UEAxMXR2VvVHJ1 +c3QgVW5pdmVyc2FsIENBIDIwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoIC +AQCzVFLByT7y2dyxUxpZKeexw0Uo5dfR7cXFS6GqdHtXr0om/Nj1XqduGdt0DE81 +WzILAePb63p3NeqqWuDW6KFXlPCQo3RWlEQwAx5cTiuFJnSCegx2oG9NzkEtoBUG +FF+3Qs17j1hhNNwqCPkuwwGmIkQcTAeC5lvO0Ep8BNMZcyfwqph/Lq9O64ceJHdq +XbboW0W63MOhBW9Wjo8QJqVJwy7XQYci4E+GymC16qFjwAGXEHm9ADwSbSsVsaxL +se4YuU6W3Nx2/zu+z18DwPw76L5GG//aQMJS9/7jOvdqdzXQ2o3rXhhqMcceujwb +KNZrVMaqW9eiLBsZzKIC9ptZvTdrhrVtgrrY6slWvKk2WP0+GfPtDCapkzj4T8Fd +IgbQl+rhrcZV4IErKIM6+vR7IVEAvlI4zs1meaj0gVbi0IMJR1FbUGrP20gaXT73 +y/Zl92zxlfgCOzJWgjl6W70viRu/obTo/3+NjN8D8WBOWBFM66M/ECuDmgFz2ZRt +hAAnZqzwcEAJQpKtT5MNYQlRJNiS1QuUYbKHsu3/mjX/hVTK7URDrBs8FmtISgoc +QIgfksILAAX/8sgCSqSqqcyZlpwvWOB94b67B9xfBHJcMTTD7F8t4D1kkCLm0ey4 +Lt1ZrtmhN79UNdxzMk+MBB4zsslG8dhcyFVQyWi9qLo2CQIDAQABo2MwYTAPBgNV +HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR281Xh+qQ2+/CfXGJx7Tz0RzgQKzAfBgNV +HSMEGDAWgBR281Xh+qQ2+/CfXGJx7Tz0RzgQKzAOBgNVHQ8BAf8EBAMCAYYwDQYJ +KoZIhvcNAQEFBQADggIBAGbBxiPz2eAubl/oz66wsCVNK/g7WJtAJDday6sWSf+z +dXkzoS9tcBc0kf5nfo/sm+VegqlVHy/c1FEHEv6sFj4sNcZj/NwQ6w2jqtB8zNHQ +L1EuxBRa3ugZ4T7GzKQp5y6EqgYweHZUcyiYWTjgAA1i00J9IZ+uPTqM1fp3DRgr +Fg5fNuH8KrUwJM/gYwx7WBr+mbpCErGR9Hxo4sjoryzqyX6uuyo9DRXcNJW2GHSo +ag/HtPQTxORb7QrSpJdMKu0vbBKJPfEncKpqA1Ihn0CoZ1Dy81of398j9tx4TuaY +T1U6U+Pv8vSfx3zYWK8pIpe44L2RLrB27FcRz+8pRPPphXpgY+RdM4kX2TGq2tbz +GDVyz4crL2MjhF2EjD9XoIj8mZEoJmmZ1I+XRL6O1UixpCgp8RW04eWe3fiPpm8m +1wk8OhwRDqZsN/etRIcsKMfYdIKz0G9KV7s1KSegi+ghp4dkNl3M2Basx7InQJJV +OCiNUW7dFGdTbHFcJoRNdVq2fmBWqU2t+5sel/MN2dKXVHfaPRK34B7vCAas+YWH +6aLcr34YEoP9VhdBLtUpgn2Z9DH2canPLAEnpQW5qrJITirvn5NSUZU8UnOOVkwX +QMAJKOSLakhT2+zNVVXxxvjpoixMptEmX36vWkzaH6byHCx+rgIW0lbQL1dTR+iS +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIB4TCCAYegAwIBAgIRKjikHJYKBN5CsiilC+g0mAIwCgYIKoZIzj0EAwIwUDEk +MCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBDQSAtIFI0MRMwEQYDVQQKEwpH +bG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWduMB4XDTEyMTExMzAwMDAwMFoX +DTM4MDExOTAzMTQwN1owUDEkMCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBD +QSAtIFI0MRMwEQYDVQQKEwpHbG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWdu +MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuMZ5049sJQ6fLjkZHAOkrprlOQcJ +FspjsbmG+IpXwVfOQvpzofdlQv8ewQCybnMO/8ch5RikqtlxP6jUuc6MHaNCMEAw +DgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFFSwe61F +uOJAf/sKbvu+M8k8o4TVMAoGCCqGSM49BAMCA0gAMEUCIQDckqGgE6bPA7DmxCGX +kPoUVy0D7O48027KqGx2vKLeuwIgJ6iFJzWbVsaj8kfSt24bAgAXqmemFZHe+pTs +ewv4n4Q= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICHjCCAaSgAwIBAgIRYFlJ4CYuu1X5CneKcflK2GwwCgYIKoZIzj0EAwMwUDEk +MCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBDQSAtIFI1MRMwEQYDVQQKEwpH +bG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWduMB4XDTEyMTExMzAwMDAwMFoX +DTM4MDExOTAzMTQwN1owUDEkMCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBD +QSAtIFI1MRMwEQYDVQQKEwpHbG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWdu +MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAER0UOlvt9Xb/pOdEh+J8LttV7HpI6SFkc +8GIxLcB6KP4ap1yztsyX50XUWPrRd21DosCHZTQKH3rd6zwzocWdTaRvQZU4f8ke +hOvRnkmSh5SHDDqFSmafnVmTTZdhBoZKo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYD +VR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPeYpSJvqB8ohREom3m7e0oPQn1kwCgYI +KoZIzj0EAwMDaAAwZQIxAOVpEslu28YxuglB4Zf4+/2a4n0Sye18ZNPLBSWLVtmg +515dTguDnFt2KaAJJiFqYgIwcdK1j1zqO+F4CYWodZI7yFz9SO8NdCKoCOJuxUnO +xwy8p2Fp8fc74SrL+SvzZpA3 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDdTCCAl2gAwIBAgILBAAAAAABFUtaw5QwDQYJKoZIhvcNAQEFBQAwVzELMAkG +A1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24gbnYtc2ExEDAOBgNVBAsTB1Jv +b3QgQ0ExGzAZBgNVBAMTEkdsb2JhbFNpZ24gUm9vdCBDQTAeFw05ODA5MDExMjAw +MDBaFw0yODAxMjgxMjAwMDBaMFcxCzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9i +YWxTaWduIG52LXNhMRAwDgYDVQQLEwdSb290IENBMRswGQYDVQQDExJHbG9iYWxT +aWduIFJvb3QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDaDuaZ +jc6j40+Kfvvxi4Mla+pIH/EqsLmVEQS98GPR4mdmzxzdzxtIK+6NiY6arymAZavp +xy0Sy6scTHAHoT0KMM0VjU/43dSMUBUc71DuxC73/OlS8pF94G3VNTCOXkNz8kHp +1Wrjsok6Vjk4bwY8iGlbKk3Fp1S4bInMm/k8yuX9ifUSPJJ4ltbcdG6TRGHRjcdG +snUOhugZitVtbNV4FpWi6cgKOOvyJBNPc1STE4U6G7weNLWLBYy5d4ux2x8gkasJ +U26Qzns3dLlwR5EiUWMWea6xrkEmCMgZK9FGqkjWZCrXgzT/LCrBbBlDSgeF59N8 +9iFo7+ryUp9/k5DPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8E +BTADAQH/MB0GA1UdDgQWBBRge2YaRQ2XyolQL30EzTSo//z9SzANBgkqhkiG9w0B +AQUFAAOCAQEA1nPnfE920I2/7LqivjTFKDK1fPxsnCwrvQmeU79rXqoRSLblCKOz +yj1hTdNGCbM+w6DjY1Ub8rrvrTnhQ7k4o+YviiY776BQVvnGCv04zcQLcFGUl5gE +38NflNUVyRRBnMRddWQVDf9VMOyGj/8N7yy5Y0b2qvzfvGn9LhJIZJrglfCm7ymP +AbEVtQwdpf5pLGkkeB6zpxxxYu7KyJesF12KwvhHhm4qxFYxldBniYUr+WymXUad +DKqC5JlR3XC321Y9YeRq4VzW9v493kHMB65jUr9TU/Qr6cf9tveCX4XSQRjbgbME +HMUfpIBvFSDJ3gyICh3WZlXi/EjJKSZp4A== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDujCCAqKgAwIBAgILBAAAAAABD4Ym5g0wDQYJKoZIhvcNAQEFBQAwTDEgMB4G +A1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjIxEzARBgNVBAoTCkdsb2JhbFNp +Z24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMDYxMjE1MDgwMDAwWhcNMjExMjE1 +MDgwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSMjETMBEG +A1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCASIwDQYJKoZI +hvcNAQEBBQADggEPADCCAQoCggEBAKbPJA6+Lm8omUVCxKs+IVSbC9N/hHD6ErPL +v4dfxn+G07IwXNb9rfF73OX4YJYJkhD10FPe+3t+c4isUoh7SqbKSaZeqKeMWhG8 +eoLrvozps6yWJQeXSpkqBy+0Hne/ig+1AnwblrjFuTosvNYSuetZfeLQBoZfXklq +tTleiDTsvHgMCJiEbKjNS7SgfQx5TfC4LcshytVsW33hoCmEofnTlEnLJGKRILzd +C9XZzPnqJworc5HGnRusyMvo4KD0L5CLTfuwNhv2GXqF4G3yYROIXJ/gkwpRl4pa +zq+r1feqCapgvdzZX99yqWATXgAByUr6P6TqBwMhAo6CygPCm48CAwEAAaOBnDCB +mTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm+IH +V2ccHsBqBt5ZtJot39wZhi4wNgYDVR0fBC8wLTAroCmgJ4YlaHR0cDovL2NybC5n +bG9iYWxzaWduLm5ldC9yb290LXIyLmNybDAfBgNVHSMEGDAWgBSb4gdXZxwewGoG +3lm0mi3f3BmGLjANBgkqhkiG9w0BAQUFAAOCAQEAmYFThxxol4aR7OBKuEQLq4Gs +J0/WwbgcQ3izDJr86iw8bmEbTUsp9Z8FHSbBuOmDAGJFtqkIk7mpM0sYmsL4h4hO +291xNBrBVNpGP+DTKqttVCL1OmLNIG+6KYnX3ZHu01yiPqFbQfXf5WRDLenVOavS +ot+3i9DAgBkcRcAtjOj4LaR0VknFBbVPFd5uRHg5h6h+u/N5GJG79G+dwfCMNYxd +AfvDbbnvRG15RjF+Cv6pgsH/76tuIMRQyV+dTZsXjAzlAcmgQWpzU/qlULRuJQ/7 +TBj0/VLZjmmx6BEP3ojY+x1J96relc8geMJgEtslQIxq/H5COEBkEveegeGTLg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDXzCCAkegAwIBAgILBAAAAAABIVhTCKIwDQYJKoZIhvcNAQELBQAwTDEgMB4G +A1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjMxEzARBgNVBAoTCkdsb2JhbFNp +Z24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMDkwMzE4MTAwMDAwWhcNMjkwMzE4 +MTAwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSMzETMBEG +A1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCASIwDQYJKoZI +hvcNAQEBBQADggEPADCCAQoCggEBAMwldpB5BngiFvXAg7aEyiie/QV2EcWtiHL8 +RgJDx7KKnQRfJMsuS+FggkbhUqsMgUdwbN1k0ev1LKMPgj0MK66X17YUhhB5uzsT +gHeMCOFJ0mpiLx9e+pZo34knlTifBtc+ycsmWQ1z3rDI6SYOgxXG71uL0gRgykmm +KPZpO/bLyCiR5Z2KYVc3rHQU3HTgOu5yLy6c+9C7v/U9AOEGM+iCK65TpjoWc4zd +QQ4gOsC0p6Hpsk+QLjJg6VfLuQSSaGjlOCZgdbKfd/+RFO+uIEn8rUAVSNECMWEZ +XriX7613t2Saer9fwRPvm2L7DWzgVGkWqQPabumDk3F2xmmFghcCAwEAAaNCMEAw +DgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFI/wS3+o +LkUkrk1Q+mOai97i3Ru8MA0GCSqGSIb3DQEBCwUAA4IBAQBLQNvAUKr+yAzv95ZU +RUm7lgAJQayzE4aGKAczymvmdLm6AC2upArT9fHxD4q/c2dKg8dEe3jgr25sbwMp +jjM5RcOO5LlXbKr8EpbsU8Yt5CRsuZRj+9xTaGdWPoO4zzUhw8lo/s7awlOqzJCK +6fBdRoyV3XpYKBovHd7NADdBj+1EbddTKJd+82cEHhXXipa0095MJ6RMG3NzdvQX +mcIfeg7jLQitChws/zyrVQ4PkX4268NXSb7hLi18YIvDQVETI53O9zJrlAGomecs +Mx86OyXShkDOOyyGeMlhLxS67ttVb9+E7gUJTb0o2HLO02JQZR7rkpeDMdmztcpH +WD9f +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIHSTCCBTGgAwIBAgIJAMnN0+nVfSPOMA0GCSqGSIb3DQEBBQUAMIGsMQswCQYD +VQQGEwJFVTFDMEEGA1UEBxM6TWFkcmlkIChzZWUgY3VycmVudCBhZGRyZXNzIGF0 +IHd3dy5jYW1lcmZpcm1hLmNvbS9hZGRyZXNzKTESMBAGA1UEBRMJQTgyNzQzMjg3 +MRswGQYDVQQKExJBQyBDYW1lcmZpcm1hIFMuQS4xJzAlBgNVBAMTHkdsb2JhbCBD +aGFtYmVyc2lnbiBSb290IC0gMjAwODAeFw0wODA4MDExMjMxNDBaFw0zODA3MzEx +MjMxNDBaMIGsMQswCQYDVQQGEwJFVTFDMEEGA1UEBxM6TWFkcmlkIChzZWUgY3Vy +cmVudCBhZGRyZXNzIGF0IHd3dy5jYW1lcmZpcm1hLmNvbS9hZGRyZXNzKTESMBAG +A1UEBRMJQTgyNzQzMjg3MRswGQYDVQQKExJBQyBDYW1lcmZpcm1hIFMuQS4xJzAl +BgNVBAMTHkdsb2JhbCBDaGFtYmVyc2lnbiBSb290IC0gMjAwODCCAiIwDQYJKoZI +hvcNAQEBBQADggIPADCCAgoCggIBAMDfVtPkOpt2RbQT2//BthmLN0EYlVJH6xed +KYiONWwGMi5HYvNJBL99RDaxccy9Wglz1dmFRP+RVyXfXjaOcNFccUMd2drvXNL7 +G706tcuto8xEpw2uIRU/uXpbknXYpBI4iRmKt4DS4jJvVpyR1ogQC7N0ZJJ0YPP2 +zxhPYLIj0Mc7zmFLmY/CDNBAspjcDahOo7kKrmCgrUVSY7pmvWjg+b4aqIG7HkF4 +ddPB/gBVsIdU6CeQNR1MM62X/JcumIS/LMmjv9GYERTtY/jKmIhYF5ntRQOXfjyG +HoiMvvKRhI9lNNgATH23MRdaKXoKGCQwoze1eqkBfSbW+Q6OWfH9GzO1KTsXO0G2 +Id3UwD2ln58fQ1DJu7xsepeY7s2MH/ucUa6LcL0nn3HAa6x9kGbo1106DbDVwo3V +yJ2dwW3Q0L9R5OP4wzg2rtandeavhENdk5IMagfeOx2YItaswTXbo6Al/3K1dh3e +beksZixShNBFks4c5eUzHdwHU1SjqoI7mjcv3N2gZOnm3b2u/GSFHTynyQbehP9r +6GsaPMWis0L7iwk+XwhSx2LE1AVxv8Rk5Pihg+g+EpuoHtQ2TS9x9o0o9oOpE9Jh +wZG7SMA0j0GMS0zbaRL/UJScIINZc+18ofLx/d33SdNDWKBWY8o9PeU1VlnpDsog +zCtLkykPAgMBAAGjggFqMIIBZjASBgNVHRMBAf8ECDAGAQH/AgEMMB0GA1UdDgQW +BBS5CcqcHtvTbDprru1U8VuTBjUuXjCB4QYDVR0jBIHZMIHWgBS5CcqcHtvTbDpr +ru1U8VuTBjUuXqGBsqSBrzCBrDELMAkGA1UEBhMCRVUxQzBBBgNVBAcTOk1hZHJp +ZCAoc2VlIGN1cnJlbnQgYWRkcmVzcyBhdCB3d3cuY2FtZXJmaXJtYS5jb20vYWRk +cmVzcykxEjAQBgNVBAUTCUE4Mjc0MzI4NzEbMBkGA1UEChMSQUMgQ2FtZXJmaXJt +YSBTLkEuMScwJQYDVQQDEx5HbG9iYWwgQ2hhbWJlcnNpZ24gUm9vdCAtIDIwMDiC +CQDJzdPp1X0jzjAOBgNVHQ8BAf8EBAMCAQYwPQYDVR0gBDYwNDAyBgRVHSAAMCow +KAYIKwYBBQUHAgEWHGh0dHA6Ly9wb2xpY3kuY2FtZXJmaXJtYS5jb20wDQYJKoZI +hvcNAQEFBQADggIBAICIf3DekijZBZRG/5BXqfEv3xoNa/p8DhxJJHkn2EaqbylZ +UohwEurdPfWbU1Rv4WCiqAm57OtZfMY18dwY6fFn5a+6ReAJ3spED8IXDneRRXoz +X1+WLGiLwUePmJs9wOzL9dWCkoQ10b42OFZyMVtHLaoXpGNR6woBrX/sdZ7LoR/x +fxKxueRkf2fWIyr0uDldmOghp+G9PUIadJpwr2hsUF1Jz//7Dl3mLEfXgTpZALVz +a2Mg9jFFCDkO9HB+QHBaP9BrQql0PSgvAm11cpUJjUhjxsYjV5KTXjXBjfkK9yyd +Yhz2rXzdpjEetrHHfoUm+qRqtdpjMNHvkzeyZi99Bffnt0uYlDXA2TopwZ2yUDMd +SqlapskD7+3056huirRXhOukP9DuqqqHW2Pok+JrqNS4cnhrG+055F3Lm6qH1U9O +AP7Zap88MQ8oAgF9mOinsKJknnn4SPIVqczmyETrP3iZ8ntxPjzxmKfFGBI/5rso +M0LpRQp8bfKGeS/Fghl9CYl8slR2iK7ewfPM4W7bMdaTrpmg7yVqc5iJWzouE4ge +v8CSlDQb4ye3ix5vQv/n6TebUB0tovkC7stYWDpxvGjjqsGvHCgfotwjZT+B6q6Z +09gwzxMNTxXJhLynSC34MCN32EZLeW32jO06f2ARePTpm67VVMB0gNELQp/B +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEADCCAuigAwIBAgIBADANBgkqhkiG9w0BAQUFADBjMQswCQYDVQQGEwJVUzEh +MB8GA1UEChMYVGhlIEdvIERhZGR5IEdyb3VwLCBJbmMuMTEwLwYDVQQLEyhHbyBE +YWRkeSBDbGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA0MDYyOTE3 +MDYyMFoXDTM0MDYyOTE3MDYyMFowYzELMAkGA1UEBhMCVVMxITAfBgNVBAoTGFRo +ZSBHbyBEYWRkeSBHcm91cCwgSW5jLjExMC8GA1UECxMoR28gRGFkZHkgQ2xhc3Mg +MiBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCCASAwDQYJKoZIhvcNAQEBBQADggEN +ADCCAQgCggEBAN6d1+pXGEmhW+vXX0iG6r7d/+TvZxz0ZWizV3GgXne77ZtJ6XCA +PVYYYwhv2vLM0D9/AlQiVBDYsoHUwHU9S3/Hd8M+eKsaA7Ugay9qK7HFiH7Eux6w +wdhFJ2+qN1j3hybX2C32qRe3H3I2TqYXP2WYktsqbl2i/ojgC95/5Y0V4evLOtXi +EqITLdiOr18SPaAIBQi2XKVlOARFmR6jYGB0xUGlcmIbYsUfb18aQr4CUWWoriMY +avx4A6lNf4DD+qta/KFApMoZFv6yyO9ecw3ud72a9nmYvLEHZ6IVDd2gWMZEewo+ +YihfukEHU1jPEX44dMX4/7VpkI+EdOqXG68CAQOjgcAwgb0wHQYDVR0OBBYEFNLE +sNKR1EwRcbNhyz2h/t2oatTjMIGNBgNVHSMEgYUwgYKAFNLEsNKR1EwRcbNhyz2h +/t2oatTjoWekZTBjMQswCQYDVQQGEwJVUzEhMB8GA1UEChMYVGhlIEdvIERhZGR5 +IEdyb3VwLCBJbmMuMTEwLwYDVQQLEyhHbyBEYWRkeSBDbGFzcyAyIENlcnRpZmlj +YXRpb24gQXV0aG9yaXR5ggEAMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQAD +ggEBADJL87LKPpH8EsahB4yOd6AzBhRckB4Y9wimPQoZ+YeAEW5p5JYXMP80kWNy +OO7MHAGjHZQopDH2esRU1/blMVgDoszOYtuURXO1v0XJJLXVggKtI3lpjbi2Tc7P +TMozI+gciKqdi0FuFskg5YmezTvacPd+mSYgFFQlq25zheabIZ0KbIIOqPjCDPoQ +HmyW74cNxA9hi63ugyuV+I6ShHI56yDqg+2DzZduCLzrTia2cyvk0/ZM/iZx4mER +dEr/VxqHD3VILs9RaRegAhJhldXRQLIQTO7ErBBDpqWeCtWVYpoNz4iCxTIM5Cuf +ReYNnyicsbkqWletNw+vHX/bvZ8= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDxTCCAq2gAwIBAgIBADANBgkqhkiG9w0BAQsFADCBgzELMAkGA1UEBhMCVVMx +EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxGjAYBgNVBAoT +EUdvRGFkZHkuY29tLCBJbmMuMTEwLwYDVQQDEyhHbyBEYWRkeSBSb290IENlcnRp +ZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5MDkwMTAwMDAwMFoXDTM3MTIzMTIz +NTk1OVowgYMxCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdBcml6b25hMRMwEQYDVQQH +EwpTY290dHNkYWxlMRowGAYDVQQKExFHb0RhZGR5LmNvbSwgSW5jLjExMC8GA1UE +AxMoR28gRGFkZHkgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgLSBHMjCCASIw +DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAL9xYgjx+lk09xvJGKP3gElY6SKD +E6bFIEMBO4Tx5oVJnyfq9oQbTqC023CYxzIBsQU+B07u9PpPL1kwIuerGVZr4oAH +/PMWdYA5UXvl+TW2dE6pjYIT5LY/qQOD+qK+ihVqf94Lw7YZFAXK6sOoBJQ7Rnwy +DfMAZiLIjWltNowRGLfTshxgtDj6AozO091GB94KPutdfMh8+7ArU6SSYmlRJQVh +GkSBjCypQ5Yj36w6gZoOKcUcqeldHraenjAKOc7xiID7S13MMuyFYkMlNAJWJwGR +tDtwKj9useiciAF9n9T521NtYJ2/LOdYq7hfRvzOxBsDPAnrSTFcaUaz4EcCAwEA +AaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYE +FDqahQcQZyi27/a9BUFuIMGU2g/eMA0GCSqGSIb3DQEBCwUAA4IBAQCZ21151fmX +WWcDYfF+OwYxdS2hII5PZYe096acvNjpL9DbWu7PdIxztDhC2gV7+AJ1uP2lsdeu +9tfeE8tTEH6KRtGX+rcuKxGrkLAngPnon1rpN5+r5N9ss4UXnT3ZJE95kTXWXwTr +gIOrmgIttRD02JDHBHNA7XIloKmf7J6raBKZV8aPEjoJpL1E/QYVN8Gb5DKj7Tjo +2GTzLH4U/ALqn83/B2gX2yKQOC16jdFU8WnjXzPKej17CuPKf1855eJ1usV2GDPO +LPAvTK33sefOT6jEm0pUBsV/fdUID+Ic/n4XuKxe9tQWskMJDE32p2u0mYRlynqI +4uJEvlz36hz1 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEMTCCAxmgAwIBAgIBADANBgkqhkiG9w0BAQUFADCBlTELMAkGA1UEBhMCR1Ix +RDBCBgNVBAoTO0hlbGxlbmljIEFjYWRlbWljIGFuZCBSZXNlYXJjaCBJbnN0aXR1 +dGlvbnMgQ2VydC4gQXV0aG9yaXR5MUAwPgYDVQQDEzdIZWxsZW5pYyBBY2FkZW1p +YyBhbmQgUmVzZWFyY2ggSW5zdGl0dXRpb25zIFJvb3RDQSAyMDExMB4XDTExMTIw +NjEzNDk1MloXDTMxMTIwMTEzNDk1MlowgZUxCzAJBgNVBAYTAkdSMUQwQgYDVQQK +EztIZWxsZW5pYyBBY2FkZW1pYyBhbmQgUmVzZWFyY2ggSW5zdGl0dXRpb25zIENl +cnQuIEF1dGhvcml0eTFAMD4GA1UEAxM3SGVsbGVuaWMgQWNhZGVtaWMgYW5kIFJl +c2VhcmNoIEluc3RpdHV0aW9ucyBSb290Q0EgMjAxMTCCASIwDQYJKoZIhvcNAQEB +BQADggEPADCCAQoCggEBAKlTAOMupvaO+mDYLZU++CwqVE7NuYRhlFhPjz2L5EPz +dYmNUeTDN9KKiE15HrcS3UN4SoqS5tdI1Q+kOilENbgH9mgdVc04UfCMJDGFr4PJ +fel3r+0ae50X+bOdOFAPplp5kYCvN66m0zH7tSYJnTxa71HFK9+WXesyHgLacEns +bgzImjeN9/E2YEsmLIKe0HjzDQ9jpFEw4fkrJxIH2Oq9GGKYsFk3fb7u8yBRQlqD +75O6aRXxYp2fmTmCobd0LovUxQt7L/DICto9eQqakxylKHJzkUOap9FNhYS5qXSP +FEDH3N6sQWRstBmbAmNtJGSPRLIl6s5ddAxjMlyNh+UCAwEAAaOBiTCBhjAPBgNV +HRMBAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAdBgNVHQ4EFgQUppFC/RNhSiOeCKQp +5dgTBCPuQSUwRwYDVR0eBEAwPqA8MAWCAy5ncjAFggMuZXUwBoIELmVkdTAGggQu +b3JnMAWBAy5ncjAFgQMuZXUwBoEELmVkdTAGgQQub3JnMA0GCSqGSIb3DQEBBQUA +A4IBAQAf73lB4XtuP7KMhjdCSk4cNx6NZrokgclPEg8hwAOXhiVtXdMiKahsog2p +6z0GW5k6x8zDmjR/qw7IThzh+uTczQ2+vyT+bOdrwg3IBp5OjWEopmr95fZi6hg8 +TqBTnbI6nOulnJEWtk2C4AwFSKls9cz4y51JtPACpf1wA+2KIaWuE4ZJwzNzvoc7 +dIsXRSZMFpGD/md9zU1jZ/rzAxKWeAaNsWftjj++n08C9bMJL/NMh98qy5V8Acys +Nnq/onN694/BtZqhFLKPM58N7yLcZnuEvUUXBj08yrl3NI/K6s8/MT7jiOOASSXI +l7WdmplNsDz4SgCbZN2fOUvRJ9e4 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDMDCCAhigAwIBAgICA+gwDQYJKoZIhvcNAQEFBQAwRzELMAkGA1UEBhMCSEsx +FjAUBgNVBAoTDUhvbmdrb25nIFBvc3QxIDAeBgNVBAMTF0hvbmdrb25nIFBvc3Qg +Um9vdCBDQSAxMB4XDTAzMDUxNTA1MTMxNFoXDTIzMDUxNTA0NTIyOVowRzELMAkG +A1UEBhMCSEsxFjAUBgNVBAoTDUhvbmdrb25nIFBvc3QxIDAeBgNVBAMTF0hvbmdr +b25nIFBvc3QgUm9vdCBDQSAxMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEArP84tulmAknjorThkPlAj3n54r15/gK97iSSHSL22oVyaf7XPwnU3ZG1ApzQ +jVrhVcNQhrkpJsLj2aDxaQMoIIBFIi1WpztUlVYiWR8o3x8gPW2iNr4joLFutbEn +PzlTCeqrauh0ssJlXI6/fMN4hM2eFvz1Lk8gKgifd/PFHsSaUmYeSF7jEAaPIpjh +ZY4bXSNmO7ilMlHIhqqhqZ5/dpTCpmy3QfDVyAY45tQM4vM7TG1QjMSDJ8EThFk9 +nnV0ttgCXjqQesBCNnLsak3c78QA3xMYV18meMjWCnl3v/evt3a5pQuEF10Q6m/h +q5URX208o1xNg1vysxmKgIsLhwIDAQABoyYwJDASBgNVHRMBAf8ECDAGAQH/AgED +MA4GA1UdDwEB/wQEAwIBxjANBgkqhkiG9w0BAQUFAAOCAQEADkbVPK7ih9legYsC +mEEIjEy82tvuJxuC52pF7BaLT4Wg87JwvVqWuspube5Gi27nKi6Wsxkz67SfqLI3 +7piol7Yutmcn1KZJ/RyTZXaeQi/cImyaT/JaFTmxcdcrUehtHJjA2Sr0oYJ71clB +oiMBdDhViw+5LmeiIAQ32pwL0xch4I+XeTRvhEgCIDMb5jREn5Fw9IBehEPCKdJs +EhTkYY2sEJCehFC78JZvRZ+K88psT/oROhUVRsPNH4NbLUES7VBnQRM9IauUiqpO +fMGx+6fWtScvl6tu4B3i0RwsH0Ti/L6RoZz71ilTc4afU9hDDl3WY4JxHYB0yvbi +AmvZWg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEAjCCAuqgAwIBAgIFORFFEJQwDQYJKoZIhvcNAQEFBQAwgYUxCzAJBgNVBAYT +AkZSMQ8wDQYDVQQIEwZGcmFuY2UxDjAMBgNVBAcTBVBhcmlzMRAwDgYDVQQKEwdQ +TS9TR0ROMQ4wDAYDVQQLEwVEQ1NTSTEOMAwGA1UEAxMFSUdDL0ExIzAhBgkqhkiG +9w0BCQEWFGlnY2FAc2dkbi5wbS5nb3V2LmZyMB4XDTAyMTIxMzE0MjkyM1oXDTIw +MTAxNzE0MjkyMlowgYUxCzAJBgNVBAYTAkZSMQ8wDQYDVQQIEwZGcmFuY2UxDjAM +BgNVBAcTBVBhcmlzMRAwDgYDVQQKEwdQTS9TR0ROMQ4wDAYDVQQLEwVEQ1NTSTEO +MAwGA1UEAxMFSUdDL0ExIzAhBgkqhkiG9w0BCQEWFGlnY2FAc2dkbi5wbS5nb3V2 +LmZyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsh/R0GLFMzvABIaI +s9z4iPf930Pfeo2aSVz2TqrMHLmh6yeJ8kbpO0px1R2OLc/mratjUMdUC24SyZA2 +xtgv2pGqaMVy/hcKshd+ebUyiHDKcMCWSo7kVc0dJ5S/znIq7Fz5cyD+vfcuiWe4 +u0dzEvfRNWk68gq5rv9GQkaiv6GFGvm/5P9JhfejcIYyHF2fYPepraX/z9E0+X1b +F8bc1g4oa8Ld8fUzaJ1O/Id8NhLWo4DoQw1VYZTqZDdH6nfK0LJYBcNdfrGoRpAx +Vs5wKpayMLh35nnAvSk7/ZR3TL0gzUEl4C7HG7vupARB0l2tEmqKm0f7yd1GQOGd +PDPQtQIDAQABo3cwdTAPBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQEAwIBRjAVBgNV +HSAEDjAMMAoGCCqBegF5AQEBMB0GA1UdDgQWBBSjBS8YYFDCiQrdKyFP/45OqDAx +NjAfBgNVHSMEGDAWgBSjBS8YYFDCiQrdKyFP/45OqDAxNjANBgkqhkiG9w0BAQUF +AAOCAQEABdwm2Pp3FURo/C9mOnTgXeQp/wYHE4RKq89toB9RlPhJy3Q2FLwV3duJ +L92PoF189RLrn544pEfMs5bZvpwlqwN+Mw+VgQ39FuCIvjfwbF3QMZsyK10XZZOY +YLxuj7GoPB7ZHPOpJkL5ZB3C55L29B5aqhlSXa/oovdgoPaN8In1buAKBQGVyYsg +Crpa/JosPL3Dt8ldeCUFP1YUmwza+zpI/pdpXsoQhvdOlgQITeywvl3cO45Pwf2a +NjSaTFR+FwNIlQgRHAdvhQh+XU3Endv7rs6y0bO4g2wdsrN58dhwmX7wEwLOXt1R +0982gaEbeC9xs/FZTEYYKKuF0mBWWg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFYDCCA0igAwIBAgIQCgFCgAAAAUUjyES1AAAAAjANBgkqhkiG9w0BAQsFADBK +MQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0MScwJQYDVQQDEx5JZGVu +VHJ1c3QgQ29tbWVyY2lhbCBSb290IENBIDEwHhcNMTQwMTE2MTgxMjIzWhcNMzQw +MTE2MTgxMjIzWjBKMQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0MScw +JQYDVQQDEx5JZGVuVHJ1c3QgQ29tbWVyY2lhbCBSb290IENBIDEwggIiMA0GCSqG +SIb3DQEBAQUAA4ICDwAwggIKAoICAQCnUBneP5k91DNG8W9RYYKyqU+PZ4ldhNlT +3Qwo2dfw/66VQ3KZ+bVdfIrBQuExUHTRgQ18zZshq0PirK1ehm7zCYofWjK9ouuU ++ehcCuz/mNKvcbO0U59Oh++SvL3sTzIwiEsXXlfEU8L2ApeN2WIrvyQfYo3fw7gp +S0l4PJNgiCL8mdo2yMKi1CxUAGc1bnO/AljwpN3lsKImesrgNqUZFvX9t++uP0D1 +bVoE/c40yiTcdCMbXTMTEl3EASX2MN0CXZ/g1Ue9tOsbobtJSdifWwLziuQkkORi +T0/Br4sOdBeo0XKIanoBScy0RnnGF7HamB4HWfp1IYVl3ZBWzvurpWCdxJ35UrCL +vYf5jysjCiN2O/cz4ckA82n5S6LgTrx+kzmEB/dEcH7+B1rlsazRGMzyNeVJSQjK +Vsk9+w8YfYs7wRPCTY/JTw436R+hDmrfYi7LNQZReSzIJTj0+kuniVyc0uMNOYZK +dHzVWYfCP04MXFL0PfdSgvHqo6z9STQaKPNBiDoT7uje/5kdX7rL6B7yuVBgwDHT +c+XvvqDtMwt0viAgxGds8AgDelWAf0ZOlqf0Hj7h9tgJ4TNkK2PXMl6f+cB7D3hv +l7yTmvmcEpB4eoCHFddydJxVdHixuuFucAS6T6C6aMN7/zHwcz09lCqxC0EOoP5N +iGVreTO01wIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB +/zAdBgNVHQ4EFgQU7UQZwNPwBovupHu+QucmVMiONnYwDQYJKoZIhvcNAQELBQAD +ggIBAA2ukDL2pkt8RHYZYR4nKM1eVO8lvOMIkPkp165oCOGUAFjvLi5+U1KMtlwH +6oi6mYtQlNeCgN9hCQCTrQ0U5s7B8jeUeLBfnLOic7iPBZM4zY0+sLj7wM+x8uwt +LRvM7Kqas6pgghstO8OEPVeKlh6cdbjTMM1gCIOQ045U8U1mwF10A0Cj7oV+wh93 +nAbowacYXVKV7cndJZ5t+qntozo00Fl72u1Q8zW/7esUTTHHYPTa8Yec4kjixsU3 ++wYQ+nVZZjFHKdp2mhzpgq7vmrlR94gjmmmVYjzlVYA211QC//G5Xc7UI2/YRYRK +W2XviQzdFKcgyxilJbQN+QHwotL0AMh0jqEqSI5l2xPE4iUXfeu+h1sXIFRRk0pT +AwvsXcoz7WL9RccvW9xYoIA55vrX/hMUpu09lEpCdNTDd1lzzY9GvlU47/rokTLq +l1gEIt44w8y8bckzOmoKaT+gyOpyj4xjhiO9bTyWnpXgSUyqorkqG5w2gXjtw+hG +4iZZRHUe2XWJUc0QhJ1hYMtd+ZciTY6Y5uN/9lu7rs3KSoFrXgvzUeF0K+l+J6fZ +mUlO+KWA2yUPHGNiiskzZ2s8EIPGrd6ozRaOjfAHN3Gf8qv8QfXBi+wAN10J5U6A +7/qxXDgGpRtK4dw4LTzcqx+QGtVKnO7RcGzM7vRX+Bi6hG6H +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFZjCCA06gAwIBAgIQCgFCgAAAAUUjz0Z8AAAAAjANBgkqhkiG9w0BAQsFADBN +MQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0MSowKAYDVQQDEyFJZGVu +VHJ1c3QgUHVibGljIFNlY3RvciBSb290IENBIDEwHhcNMTQwMTE2MTc1MzMyWhcN +MzQwMTE2MTc1MzMyWjBNMQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0 +MSowKAYDVQQDEyFJZGVuVHJ1c3QgUHVibGljIFNlY3RvciBSb290IENBIDEwggIi +MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC2IpT8pEiv6EdrCvsnduTyP4o7 +ekosMSqMjbCpwzFrqHd2hCa2rIFCDQjrVVi7evi8ZX3yoG2LqEfpYnYeEe4IFNGy +RBb06tD6Hi9e28tzQa68ALBKK0CyrOE7S8ItneShm+waOh7wCLPQ5CQ1B5+ctMlS +bdsHyo+1W/CD80/HLaXIrcuVIKQxKFdYWuSNG5qrng0M8gozOSI5Cpcu81N3uURF +/YTLNiCBWS2ab21ISGHKTN9T0a9SvESfqy9rg3LvdYDaBjMbXcjaY8ZNzaxmMc3R +3j6HEDbhuaR672BQssvKplbgN6+rNBM5Jeg5ZuSYeqoSmJxZZoY+rfGwyj4GD3vw +EUs3oERte8uojHH01bWRNszwFcYr3lEXsZdMUD2xlVl8BX0tIdUAvwFnol57plzy +9yLxkA2T26pEUWbMfXYD62qoKjgZl3YNa4ph+bz27nb9cCvdKTz4Ch5bQhyLVi9V +GxyhLrXHFub4qjySjmm2AcG1hp2JDws4lFTo6tyePSW8Uybt1as5qsVATFSrsrTZ +2fjXctscvG29ZV/viDUqZi/u9rNl8DONfJhBaUYPQxxp+pu10GFqzcpL2UyQRqsV +WaFHVCkugyhfHMKiq3IXAAaOReyL4jM9f9oZRORicsPfIsbyVtTdX5Vy7W1f90gD +W/3FKqD2cyOEEBsB5wIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/ +BAUwAwEB/zAdBgNVHQ4EFgQU43HgntinQtnbcZFrlJPrw6PRFKMwDQYJKoZIhvcN +AQELBQADggIBAEf63QqwEZE4rU1d9+UOl1QZgkiHVIyqZJnYWv6IAcVYpZmxI1Qj +t2odIFflAWJBF9MJ23XLblSQdf4an4EKwt3X9wnQW3IV5B4Jaj0z8yGa5hV+rVHV +DRDtfULAj+7AmgjVQdZcDiFpboBhDhXAuM/FSRJSzL46zNQuOAXeNf0fb7iAaJg9 +TaDKQGXSc3z1i9kKlT/YPyNtGtEqJBnZhbMX73huqVjRI9PHE+1yJX9dsXNw0H8G +lwmEKYBhHfpe/3OsoOOJuBxxFcbeMX8S3OFtm6/n6J91eEyrRjuazr8FGF1NFTwW +mhlQBJqymm9li1JfPFgEKCXAZmExfrngdbkaqIHWchezxQMxNRF4eKLg6TCMf4Df +WN88uieW4oA0beOY02QnrEh+KHdcxiVhJfiFDGX6xDIvpZgF5PgLZxYWxoK4Mhn5 ++bl53B/N66+rDt0b20XkeucC4pVd/GnwU2lhlXV5C15V5jgclKlZM57IcXR5f1GJ +tshquDDIajjDbp7hNxbqBWJMWxJH7ae0s1hWx0nzfxJoCTFx8G34Tkf71oXuxVhA +GaQdp/lLQzfcaFpPz+vCZHTetBXZ9FRUGi8c15dxVJCO2SCdUyt/q4/i6jC8UDfv +8Ue1fXwsBOxonbRJRBD0ckscZOf85muQ3Wl9af0AVqW3rLatt8o+Ae+c +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIF8TCCA9mgAwIBAgIQALC3WhZIX7/hy/WL1xnmfTANBgkqhkiG9w0BAQsFADA4 +MQswCQYDVQQGEwJFUzEUMBIGA1UECgwLSVpFTlBFIFMuQS4xEzARBgNVBAMMCkl6 +ZW5wZS5jb20wHhcNMDcxMjEzMTMwODI4WhcNMzcxMjEzMDgyNzI1WjA4MQswCQYD +VQQGEwJFUzEUMBIGA1UECgwLSVpFTlBFIFMuQS4xEzARBgNVBAMMCkl6ZW5wZS5j +b20wggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDJ03rKDx6sp4boFmVq +scIbRTJxldn+EFvMr+eleQGPicPK8lVx93e+d5TzcqQsRNiekpsUOqHnJJAKClaO +xdgmlOHZSOEtPtoKct2jmRXagaKH9HtuJneJWK3W6wyyQXpzbm3benhB6QiIEn6H +LmYRY2xU+zydcsC8Lv/Ct90NduM61/e0aL6i9eOBbsFGb12N4E3GVFWJGjMxCrFX +uaOKmMPsOzTFlUFpfnXCPCDFYbpRR6AgkJOhkEvzTnyFRVSa0QUmQbC1TR0zvsQD +yCV8wXDbO/QJLVQnSKwv4cSsPsjLkkxTOTcj7NMB+eAJRE1NZMDhDVqHIrytG6P+ +JrUV86f8hBnp7KGItERphIPzidF0BqnMC9bC3ieFUCbKF7jJeodWLBoBHmy+E60Q +rLUk9TiRodZL2vG70t5HtfG8gfZZa88ZU+mNFctKy6lvROUbQc/hhqfK0GqfvEyN +BjNaooXlkDWgYlwWTvDjovoDGrQscbNYLN57C9saD+veIR8GdwYDsMnvmfzAuU8L +hij+0rnq49qlw0dpEuDb8PYZi+17cNcC1u2HGCgsBCRMd+RIihrGO5rUD8r6ddIB +QFqNeb+Lz0vPqhbBleStTIo+F5HUsWLlguWABKQDfo2/2n+iD5dPDNMN+9fR5XJ+ +HMh3/1uaD7euBUbl8agW7EekFwIDAQABo4H2MIHzMIGwBgNVHREEgagwgaWBD2lu +Zm9AaXplbnBlLmNvbaSBkTCBjjFHMEUGA1UECgw+SVpFTlBFIFMuQS4gLSBDSUYg +QTAxMzM3MjYwLVJNZXJjLlZpdG9yaWEtR2FzdGVpeiBUMTA1NSBGNjIgUzgxQzBB +BgNVBAkMOkF2ZGEgZGVsIE1lZGl0ZXJyYW5lbyBFdG9yYmlkZWEgMTQgLSAwMTAx +MCBWaXRvcmlhLUdhc3RlaXowDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC +AQYwHQYDVR0OBBYEFB0cZQ6o8iV7tJHP5LGx5r1VdGwFMA0GCSqGSIb3DQEBCwUA +A4ICAQB4pgwWSp9MiDrAyw6lFn2fuUhfGI8NYjb2zRlrrKvV9pF9rnHzP7MOeIWb +laQnIUdCSnxIOvVFfLMMjlF4rJUT3sb9fbgakEyrkgPH7UIBzg/YsfqikuFgba56 +awmqxinuaElnMIAkejEWOVt+8Rwu3WwJrfIxwYJOubv5vr8qhT/AQKM6WfxZSzwo +JNu0FXWuDYi6LnPAvViH5ULy617uHjAimcs30cQhbIHsvm0m5hzkQiCeR7Csg1lw +LDXWrzY0tM07+DKo7+N4ifuNRSzanLh+QBxh5z6ikixL8s36mLYp//Pye6kfLqCT +VyvehQP5aTfLnnhqBbTFMXiJ7HqnheG5ezzevh55hM6fcA5ZwjUukCox2eRFekGk +LhObNA5me0mrZJfQRsN5nXJQY6aYWwa9SG3YOYNw6DXwBdGqvOPbyALqfP2C2sJb +UjWumDqtujWTI6cfSN01RpiyEGjkpTHCClguGYEQyVB1/OpaFs4R1+7vUIgtYf8/ +QnMFlEPVjjxOAToZpR9GTnfQXeWBIiGH/pR9hNiTrdZoQ0iy2+tzJOeRf1SktoA+ +naM8THLCV8Sg1Mw4J87VBp6iSNnpn86CcDaTmjvfliHjWbcM2pE38P1ZWrOZyGls +QyYBNWNgVYkDOnXYukrZVP/u3oDYLdE41V4tC5h9Pmzb/CaIxw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIE5jCCA86gAwIBAgIEO45L/DANBgkqhkiG9w0BAQUFADBdMRgwFgYJKoZIhvcN +AQkBFglwa2lAc2suZWUxCzAJBgNVBAYTAkVFMSIwIAYDVQQKExlBUyBTZXJ0aWZp +dHNlZXJpbWlza2Vza3VzMRAwDgYDVQQDEwdKdXVyLVNLMB4XDTAxMDgzMDE0MjMw +MVoXDTE2MDgyNjE0MjMwMVowXTEYMBYGCSqGSIb3DQEJARYJcGtpQHNrLmVlMQsw +CQYDVQQGEwJFRTEiMCAGA1UEChMZQVMgU2VydGlmaXRzZWVyaW1pc2tlc2t1czEQ +MA4GA1UEAxMHSnV1ci1TSzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +AIFxNj4zB9bjMI0TfncyRsvPGbJgMUaXhvSYRqTCZUXP00B841oiqBB4M8yIsdOB +SvZiF3tfTQou0M+LI+5PAk676w7KvRhj6IAcjeEcjT3g/1tf6mTll+g/mX8MCgkz +ABpTpyHhOEvWgxutr2TC+Rx6jGZITWYfGAriPrsfB2WThbkasLnE+w0R9vXW+RvH +LCu3GFH+4Hv2qEivbDtPL+/40UceJlfwUR0zlv/vWT3aTdEVNMfqPxZIe5EcgEMP +PbgFPtGzlc3Yyg/CQ2fbt5PgIoIuvvVoKIO5wTtpeyDaTpxt4brNj3pssAki14sL +2xzVWiZbDcDq5WDQn/413z8CAwEAAaOCAawwggGoMA8GA1UdEwEB/wQFMAMBAf8w +ggEWBgNVHSAEggENMIIBCTCCAQUGCisGAQQBzh8BAQEwgfYwgdAGCCsGAQUFBwIC +MIHDHoHAAFMAZQBlACAAcwBlAHIAdABpAGYAaQBrAGEAYQB0ACAAbwBuACAAdgDk +AGwAagBhAHMAdABhAHQAdQBkACAAQQBTAC0AaQBzACAAUwBlAHIAdABpAGYAaQB0 +AHMAZQBlAHIAaQBtAGkAcwBrAGUAcwBrAHUAcwAgAGEAbABhAG0ALQBTAEsAIABz +AGUAcgB0AGkAZgBpAGsAYQBhAHQAaQBkAGUAIABrAGkAbgBuAGkAdABhAG0AaQBz +AGUAawBzMCEGCCsGAQUFBwIBFhVodHRwOi8vd3d3LnNrLmVlL2Nwcy8wKwYDVR0f +BCQwIjAgoB6gHIYaaHR0cDovL3d3dy5zay5lZS9qdXVyL2NybC8wHQYDVR0OBBYE +FASqekej5ImvGs8KQKcYP2/v6X2+MB8GA1UdIwQYMBaAFASqekej5ImvGs8KQKcY +P2/v6X2+MA4GA1UdDwEB/wQEAwIB5jANBgkqhkiG9w0BAQUFAAOCAQEAe8EYlFOi +CfP+JmeaUOTDBS8rNXiRTHyoERF5TElZrMj3hWVcRrs7EKACr81Ptcw2Kuxd/u+g +kcm2k298gFTsxwhwDY77guwqYHhpNjbRxZyLabVAyJRld/JXIWY7zoVAtjNjGr95 +HvxcHdMdkxuLDF2FvZkwMhgJkVLpfKG6/2SSmuz+Ne6ML678IIbsSt4beDI3poHS +na9aEhbKmVv8b20OxaAehsmR0FyYgl9jDIpaq9iVpszLita/ZEuOyoqysOkhMp6q +qIWYNIE5ITuoOlIyPfZrN4YGWhWY3PARZv40ILcD9EEQfTmEeZZyY7aWAuVrua0Z +TbvGRNs2yyqcjg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIHqDCCBpCgAwIBAgIRAMy4579OKRr9otxmpRwsDxEwDQYJKoZIhvcNAQEFBQAw +cjELMAkGA1UEBhMCSFUxETAPBgNVBAcTCEJ1ZGFwZXN0MRYwFAYDVQQKEw1NaWNy +b3NlYyBMdGQuMRQwEgYDVQQLEwtlLVN6aWdubyBDQTEiMCAGA1UEAxMZTWljcm9z +ZWMgZS1Temlnbm8gUm9vdCBDQTAeFw0wNTA0MDYxMjI4NDRaFw0xNzA0MDYxMjI4 +NDRaMHIxCzAJBgNVBAYTAkhVMREwDwYDVQQHEwhCdWRhcGVzdDEWMBQGA1UEChMN +TWljcm9zZWMgTHRkLjEUMBIGA1UECxMLZS1Temlnbm8gQ0ExIjAgBgNVBAMTGU1p +Y3Jvc2VjIGUtU3ppZ25vIFJvb3QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAw +ggEKAoIBAQDtyADVgXvNOABHzNuEwSFpLHSQDCHZU4ftPkNEU6+r+ICbPHiN1I2u +uO/TEdyB5s87lozWbxXGd36hL+BfkrYn13aaHUM86tnsL+4582pnS4uCzyL4ZVX+ +LMsvfUh6PXX5qqAnu3jCBspRwn5mS6/NoqdNAoI/gqyFxuEPkEeZlApxcpMqyabA +vjxWTHOSJ/FrtfX9/DAFYJLG65Z+AZHCabEeHXtTRbjcQR/Ji3HWVBTji1R4P770 +Yjtb9aPs1ZJ04nQw7wHb4dSrmZsqa/i9phyGI0Jf7Enemotb9HI6QMVJPqW+jqpx +62z69Rrkav17fVVA71hu5tnVvCSrwe+3AgMBAAGjggQ3MIIEMzBnBggrBgEFBQcB +AQRbMFkwKAYIKwYBBQUHMAGGHGh0dHBzOi8vcmNhLmUtc3ppZ25vLmh1L29jc3Aw +LQYIKwYBBQUHMAKGIWh0dHA6Ly93d3cuZS1zemlnbm8uaHUvUm9vdENBLmNydDAP +BgNVHRMBAf8EBTADAQH/MIIBcwYDVR0gBIIBajCCAWYwggFiBgwrBgEEAYGoGAIB +AQEwggFQMCgGCCsGAQUFBwIBFhxodHRwOi8vd3d3LmUtc3ppZ25vLmh1L1NaU1ov +MIIBIgYIKwYBBQUHAgIwggEUHoIBEABBACAAdABhAG4A+gBzAO0AdAB2AOEAbgB5 +ACAA6QByAHQAZQBsAG0AZQB6AOkAcwDpAGgAZQB6ACAA6QBzACAAZQBsAGYAbwBn +AGEAZADhAHMA4QBoAG8AegAgAGEAIABTAHoAbwBsAGcA4QBsAHQAYQB0APMAIABT +AHoAbwBsAGcA4QBsAHQAYQB0AOEAcwBpACAAUwB6AGEAYgDhAGwAeQB6AGEAdABh +ACAAcwB6AGUAcgBpAG4AdAAgAGsAZQBsAGwAIABlAGwAagDhAHIAbgBpADoAIABo +AHQAdABwADoALwAvAHcAdwB3AC4AZQAtAHMAegBpAGcAbgBvAC4AaAB1AC8AUwBa +AFMAWgAvMIHIBgNVHR8EgcAwgb0wgbqggbeggbSGIWh0dHA6Ly93d3cuZS1zemln +bm8uaHUvUm9vdENBLmNybIaBjmxkYXA6Ly9sZGFwLmUtc3ppZ25vLmh1L0NOPU1p +Y3Jvc2VjJTIwZS1Temlnbm8lMjBSb290JTIwQ0EsT1U9ZS1Temlnbm8lMjBDQSxP +PU1pY3Jvc2VjJTIwTHRkLixMPUJ1ZGFwZXN0LEM9SFU/Y2VydGlmaWNhdGVSZXZv +Y2F0aW9uTGlzdDtiaW5hcnkwDgYDVR0PAQH/BAQDAgEGMIGWBgNVHREEgY4wgYuB +EGluZm9AZS1zemlnbm8uaHWkdzB1MSMwIQYDVQQDDBpNaWNyb3NlYyBlLVN6aWdu +w7MgUm9vdCBDQTEWMBQGA1UECwwNZS1TemlnbsOzIEhTWjEWMBQGA1UEChMNTWlj +cm9zZWMgS2Z0LjERMA8GA1UEBxMIQnVkYXBlc3QxCzAJBgNVBAYTAkhVMIGsBgNV +HSMEgaQwgaGAFMegSXUWYYTbMUuE0vE3QJDvTtz3oXakdDByMQswCQYDVQQGEwJI +VTERMA8GA1UEBxMIQnVkYXBlc3QxFjAUBgNVBAoTDU1pY3Jvc2VjIEx0ZC4xFDAS +BgNVBAsTC2UtU3ppZ25vIENBMSIwIAYDVQQDExlNaWNyb3NlYyBlLVN6aWdubyBS +b290IENBghEAzLjnv04pGv2i3GalHCwPETAdBgNVHQ4EFgQUx6BJdRZhhNsxS4TS +8TdAkO9O3PcwDQYJKoZIhvcNAQEFBQADggEBANMTnGZjWS7KXHAM/IO8VbH0jgds +ZifOwTsgqRy7RlRw7lrMoHfqaEQn6/Ip3Xep1fvj1KcExJW4C+FEaGAHQzAxQmHl +7tnlJNUb3+FKG6qfx1/4ehHqE5MAyopYse7tDk2016g2JnzgOsHVV4Lxdbb9iV/a +86g4nzUGCM4ilb7N1fy+W955a9x6qWVmvrElWl/tftOsRm1M9DKHtCAE4Gx4sHfR +hUZLphK3dehKyVZs15KrnfVJONJPU+NVkBHbmJbGSfI+9J8b4PeI3CVimUTYc78/ +MPMMNz7UwiiAc7EBt51alhQBS6kRnSlqLtBdgcDPsiBDxwPgN05dCtxZICU= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIECjCCAvKgAwIBAgIJAMJ+QwRORz8ZMA0GCSqGSIb3DQEBCwUAMIGCMQswCQYD +VQQGEwJIVTERMA8GA1UEBwwIQnVkYXBlc3QxFjAUBgNVBAoMDU1pY3Jvc2VjIEx0 +ZC4xJzAlBgNVBAMMHk1pY3Jvc2VjIGUtU3ppZ25vIFJvb3QgQ0EgMjAwOTEfMB0G +CSqGSIb3DQEJARYQaW5mb0BlLXN6aWduby5odTAeFw0wOTA2MTYxMTMwMThaFw0y +OTEyMzAxMTMwMThaMIGCMQswCQYDVQQGEwJIVTERMA8GA1UEBwwIQnVkYXBlc3Qx +FjAUBgNVBAoMDU1pY3Jvc2VjIEx0ZC4xJzAlBgNVBAMMHk1pY3Jvc2VjIGUtU3pp +Z25vIFJvb3QgQ0EgMjAwOTEfMB0GCSqGSIb3DQEJARYQaW5mb0BlLXN6aWduby5o +dTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOn4j/NjrdqG2KfgQvvP +kd6mJviZpWNwrZuuyjNAfW2WbqEORO7hE52UQlKavXWFdCyoDh2Tthi3jCyoz/tc +cbna7P7ofo/kLx2yqHWH2Leh5TvPmUpG0IMZfcChEhyVbUr02MelTTMuhTlAdX4U +fIASmFDHQWe4oIBhVKZsTh/gnQ4H6cm6M+f+wFUoLAKApxn1ntxVUwOXewdI/5n7 +N4okxFnMUBBjjqqpGrCEGob5X7uxUG6k0QrM1XF+H6cbfPVTbiJfyyvm1HxdrtbC +xkzlBQHZ7Vf8wSN5/PrIJIOV87VqUQHQd9bpEqH5GoP7ghu5sJf0dgYzQ0mg/wu1 ++rUCAwEAAaOBgDB+MA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0G +A1UdDgQWBBTLD8bfQkPMPcu1SCOhGnqmKrs0aDAfBgNVHSMEGDAWgBTLD8bfQkPM +Pcu1SCOhGnqmKrs0aDAbBgNVHREEFDASgRBpbmZvQGUtc3ppZ25vLmh1MA0GCSqG +SIb3DQEBCwUAA4IBAQDJ0Q5eLtXMs3w+y/w9/w0olZMEyL/azXm4Q5DwpL7v8u8h +mLzU1F0G9u5C7DBsoKqpyvGvivo/C3NqPuouQH4frlRheesuCDfXI/OMn74dseGk +ddug4lQUsbocKaQY9hK6ohQU4zE1yED/t+AFdlfBHFny+L/k7SViXITwfn4fs775 +tyERzAMBVnCnEJIeGzSBHq2cGsMEPO0CYdYeBvNfOofyK/FFh+U9rNHHV4S9a67c +2Pm2G2JwCz02yULyMtd6YebS2z3PyKnJm9zbWETXbzivf3jTo60adbocwTZ8jx5t +HMN1Rq41Bab2XD0h7lbwyYIiLXpUq3DDfSJlgnCW +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEFTCCAv2gAwIBAgIGSUEs5AAQMA0GCSqGSIb3DQEBCwUAMIGnMQswCQYDVQQG +EwJIVTERMA8GA1UEBwwIQnVkYXBlc3QxFTATBgNVBAoMDE5ldExvY2sgS2Z0LjE3 +MDUGA1UECwwuVGFuw7pzw610dsOhbnlraWFkw7NrIChDZXJ0aWZpY2F0aW9uIFNl +cnZpY2VzKTE1MDMGA1UEAwwsTmV0TG9jayBBcmFueSAoQ2xhc3MgR29sZCkgRsWR +dGFuw7pzw610dsOhbnkwHhcNMDgxMjExMTUwODIxWhcNMjgxMjA2MTUwODIxWjCB +pzELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MRUwEwYDVQQKDAxOZXRM +b2NrIEtmdC4xNzA1BgNVBAsMLlRhbsO6c8OtdHbDoW55a2lhZMOzayAoQ2VydGlm +aWNhdGlvbiBTZXJ2aWNlcykxNTAzBgNVBAMMLE5ldExvY2sgQXJhbnkgKENsYXNz +IEdvbGQpIEbFkXRhbsO6c8OtdHbDoW55MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A +MIIBCgKCAQEAxCRec75LbRTDofTjl5Bu0jBFHjzuZ9lk4BqKf8owyoPjIMHj9DrT +lF8afFttvzBPhCf2nx9JvMaZCpDyD/V/Q4Q3Y1GLeqVw/HpYzY6b7cNGbIRwXdrz +AZAj/E4wqX7hJ2Pn7WQ8oLjJM2P+FpD/sLj916jAwJRDC7bVWaaeVtAkH3B5r9s5 +VA1lddkVQZQBr17s9o3x/61k/iCa11zr/qYfCGSji3ZVrR47KGAuhyXoqq8fxmRG +ILdwfzzeSNuWU7c5d+Qa4scWhHaXWy+7GRWF+GmF9ZmnqfI0p6m2pgP8b4Y9VHx2 +BJtr+UBdADTHLpl1neWIA6pN+APSQnbAGwIDAKiLo0UwQzASBgNVHRMBAf8ECDAG +AQH/AgEEMA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUzPpnk/C2uNClwB7zU/2M +U9+D15YwDQYJKoZIhvcNAQELBQADggEBAKt/7hwWqZw8UQCgwBEIBaeZ5m8BiFRh +bvG5GK1Krf6BQCOUL/t1fC8oS2IkgYIL9WHxHG64YTjrgfpioTtaYtOUZcTh5m2C ++C8lcLIhJsFyUR+MLMOEkMNaj7rP9KdlpeuY0fsFskZ1FSNqb4VjMIDw1Z4fKRzC +bLBQWV2QWzuoDTDPv31/zvGdg73JRm4gpvlhUbohL3u+pRVjodSVh/GeufOJ8z2F +uLjbvrW5KfnaNwUASZQDhETnv0Mxz3WLJdH0pmT1kvarBes96aULNmLazAZfNou2 +XjG4Kvte9nHfRCaexOYNkbQudZWAUWpLMKawYqGT8ZvYzsRjdT9ZR7E= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFSzCCBLSgAwIBAgIBaTANBgkqhkiG9w0BAQQFADCBmTELMAkGA1UEBhMCSFUx +ETAPBgNVBAcTCEJ1ZGFwZXN0MScwJQYDVQQKEx5OZXRMb2NrIEhhbG96YXRiaXp0 +b25zYWdpIEtmdC4xGjAYBgNVBAsTEVRhbnVzaXR2YW55a2lhZG9rMTIwMAYDVQQD +EylOZXRMb2NrIFV6bGV0aSAoQ2xhc3MgQikgVGFudXNpdHZhbnlraWFkbzAeFw05 +OTAyMjUxNDEwMjJaFw0xOTAyMjAxNDEwMjJaMIGZMQswCQYDVQQGEwJIVTERMA8G +A1UEBxMIQnVkYXBlc3QxJzAlBgNVBAoTHk5ldExvY2sgSGFsb3phdGJpenRvbnNh +Z2kgS2Z0LjEaMBgGA1UECxMRVGFudXNpdHZhbnlraWFkb2sxMjAwBgNVBAMTKU5l +dExvY2sgVXpsZXRpIChDbGFzcyBCKSBUYW51c2l0dmFueWtpYWRvMIGfMA0GCSqG +SIb3DQEBAQUAA4GNADCBiQKBgQCx6gTsIKAjwo84YM/HRrPVG/77uZmeBNwcf4xK +gZjupNTKihe5In+DCnVMm8Bp2GQ5o+2So/1bXHQawEfKOml2mrriRBf8TKPV/riX +iK+IA4kfpPIEPsgHC+b5sy96YhQJRhTKZPWLgLViqNhr1nGTLbO/CVRY7QbrqHvc +Q7GhaQIDAQABo4ICnzCCApswEgYDVR0TAQH/BAgwBgEB/wIBBDAOBgNVHQ8BAf8E +BAMCAAYwEQYJYIZIAYb4QgEBBAQDAgAHMIICYAYJYIZIAYb4QgENBIICURaCAk1G +SUdZRUxFTSEgRXplbiB0YW51c2l0dmFueSBhIE5ldExvY2sgS2Z0LiBBbHRhbGFu +b3MgU3pvbGdhbHRhdGFzaSBGZWx0ZXRlbGVpYmVuIGxlaXJ0IGVsamFyYXNvayBh +bGFwamFuIGtlc3p1bHQuIEEgaGl0ZWxlc2l0ZXMgZm9seWFtYXRhdCBhIE5ldExv +Y2sgS2Z0LiB0ZXJtZWtmZWxlbG9zc2VnLWJpenRvc2l0YXNhIHZlZGkuIEEgZGln +aXRhbGlzIGFsYWlyYXMgZWxmb2dhZGFzYW5hayBmZWx0ZXRlbGUgYXogZWxvaXJ0 +IGVsbGVub3J6ZXNpIGVsamFyYXMgbWVndGV0ZWxlLiBBeiBlbGphcmFzIGxlaXJh +c2EgbWVndGFsYWxoYXRvIGEgTmV0TG9jayBLZnQuIEludGVybmV0IGhvbmxhcGph +biBhIGh0dHBzOi8vd3d3Lm5ldGxvY2submV0L2RvY3MgY2ltZW4gdmFneSBrZXJo +ZXRvIGF6IGVsbGVub3J6ZXNAbmV0bG9jay5uZXQgZS1tYWlsIGNpbWVuLiBJTVBP +UlRBTlQhIFRoZSBpc3N1YW5jZSBhbmQgdGhlIHVzZSBvZiB0aGlzIGNlcnRpZmlj +YXRlIGlzIHN1YmplY3QgdG8gdGhlIE5ldExvY2sgQ1BTIGF2YWlsYWJsZSBhdCBo +dHRwczovL3d3dy5uZXRsb2NrLm5ldC9kb2NzIG9yIGJ5IGUtbWFpbCBhdCBjcHNA +bmV0bG9jay5uZXQuMA0GCSqGSIb3DQEBBAUAA4GBAATbrowXr/gOkDFOzT4JwG06 +sPgzTEdM43WIEJessDgVkcYplswhwG08pXTP2IKlOcNl40JwuyKQ433bNXbhoLXa +n3BukxowOR0w2y7jfLKRstE3Kfq51hdcR0/jHTjrn9V7lagonhVK0dHQKwCXoOKS +NitjrFgBazMpUIaD8QFI +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFTzCCBLigAwIBAgIBaDANBgkqhkiG9w0BAQQFADCBmzELMAkGA1UEBhMCSFUx +ETAPBgNVBAcTCEJ1ZGFwZXN0MScwJQYDVQQKEx5OZXRMb2NrIEhhbG96YXRiaXp0 +b25zYWdpIEtmdC4xGjAYBgNVBAsTEVRhbnVzaXR2YW55a2lhZG9rMTQwMgYDVQQD +EytOZXRMb2NrIEV4cHJlc3N6IChDbGFzcyBDKSBUYW51c2l0dmFueWtpYWRvMB4X +DTk5MDIyNTE0MDgxMVoXDTE5MDIyMDE0MDgxMVowgZsxCzAJBgNVBAYTAkhVMREw +DwYDVQQHEwhCdWRhcGVzdDEnMCUGA1UEChMeTmV0TG9jayBIYWxvemF0Yml6dG9u +c2FnaSBLZnQuMRowGAYDVQQLExFUYW51c2l0dmFueWtpYWRvazE0MDIGA1UEAxMr +TmV0TG9jayBFeHByZXNzeiAoQ2xhc3MgQykgVGFudXNpdHZhbnlraWFkbzCBnzAN +BgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA6+ywbGGKIyWvYCDj2Z/8kwvbXY2wobNA +OoLO/XXgeDIDhlqGlZHtU/qdQPzm6N3ZW3oDvV3zOwzDUXmbrVWg6dADEK8KuhRC +2VImESLH0iDMgqSaqf64gXadarfSNnU+sYYJ9m5tfk63euyucYT2BDMIJTLrdKwW +RMbkQJMdf60CAwEAAaOCAp8wggKbMBIGA1UdEwEB/wQIMAYBAf8CAQQwDgYDVR0P +AQH/BAQDAgAGMBEGCWCGSAGG+EIBAQQEAwIABzCCAmAGCWCGSAGG+EIBDQSCAlEW +ggJNRklHWUVMRU0hIEV6ZW4gdGFudXNpdHZhbnkgYSBOZXRMb2NrIEtmdC4gQWx0 +YWxhbm9zIFN6b2xnYWx0YXRhc2kgRmVsdGV0ZWxlaWJlbiBsZWlydCBlbGphcmFz +b2sgYWxhcGphbiBrZXN6dWx0LiBBIGhpdGVsZXNpdGVzIGZvbHlhbWF0YXQgYSBO +ZXRMb2NrIEtmdC4gdGVybWVrZmVsZWxvc3NlZy1iaXp0b3NpdGFzYSB2ZWRpLiBB +IGRpZ2l0YWxpcyBhbGFpcmFzIGVsZm9nYWRhc2FuYWsgZmVsdGV0ZWxlIGF6IGVs +b2lydCBlbGxlbm9yemVzaSBlbGphcmFzIG1lZ3RldGVsZS4gQXogZWxqYXJhcyBs +ZWlyYXNhIG1lZ3RhbGFsaGF0byBhIE5ldExvY2sgS2Z0LiBJbnRlcm5ldCBob25s +YXBqYW4gYSBodHRwczovL3d3dy5uZXRsb2NrLm5ldC9kb2NzIGNpbWVuIHZhZ3kg +a2VyaGV0byBheiBlbGxlbm9yemVzQG5ldGxvY2submV0IGUtbWFpbCBjaW1lbi4g +SU1QT1JUQU5UISBUaGUgaXNzdWFuY2UgYW5kIHRoZSB1c2Ugb2YgdGhpcyBjZXJ0 +aWZpY2F0ZSBpcyBzdWJqZWN0IHRvIHRoZSBOZXRMb2NrIENQUyBhdmFpbGFibGUg +YXQgaHR0cHM6Ly93d3cubmV0bG9jay5uZXQvZG9jcyBvciBieSBlLW1haWwgYXQg +Y3BzQG5ldGxvY2submV0LjANBgkqhkiG9w0BAQQFAAOBgQAQrX/XDDKACtiG8XmY +ta3UzbM2xJZIwVzNmtkFLp++UOv0JhQQLdRmF/iewSf98e3ke0ugbLWrmldwpu2g +pO0u9f38vf5NNwgMvOOWgyL1SRt/Syu0VMGAfJlOHdCM7tCs5ZL6dVb+ZKATj7i4 +Fp1hBWeAyNDYpQcCNJgEjTME1A== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIGfTCCBWWgAwIBAgICAQMwDQYJKoZIhvcNAQEEBQAwga8xCzAJBgNVBAYTAkhV +MRAwDgYDVQQIEwdIdW5nYXJ5MREwDwYDVQQHEwhCdWRhcGVzdDEnMCUGA1UEChMe +TmV0TG9jayBIYWxvemF0Yml6dG9uc2FnaSBLZnQuMRowGAYDVQQLExFUYW51c2l0 +dmFueWtpYWRvazE2MDQGA1UEAxMtTmV0TG9jayBLb3pqZWd5em9pIChDbGFzcyBB +KSBUYW51c2l0dmFueWtpYWRvMB4XDTk5MDIyNDIzMTQ0N1oXDTE5MDIxOTIzMTQ0 +N1owga8xCzAJBgNVBAYTAkhVMRAwDgYDVQQIEwdIdW5nYXJ5MREwDwYDVQQHEwhC +dWRhcGVzdDEnMCUGA1UEChMeTmV0TG9jayBIYWxvemF0Yml6dG9uc2FnaSBLZnQu +MRowGAYDVQQLExFUYW51c2l0dmFueWtpYWRvazE2MDQGA1UEAxMtTmV0TG9jayBL +b3pqZWd5em9pIChDbGFzcyBBKSBUYW51c2l0dmFueWtpYWRvMIIBIjANBgkqhkiG +9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvHSMD7tM9DceqQWC2ObhbHDqeLVu0ThEDaiD +zl3S1tWBxdRL51uUcCbbO51qTGL3cfNk1mE7PetzozfZz+qMkjvN9wfcZnSX9EUi +3fRc4L9t875lM+QVOr/bmJBVOMTtplVjC7B4BPTjbsE/jvxReB+SnoPC/tmwqcm8 +WgD/qaiYdPv2LD4VOQ22BFWoDpggQrOxJa1+mm9dU7GrDPzr4PN6s6iz/0b2Y6LY +Oph7tqyF/7AlT3Rj5xMHpQqPBffAZG9+pyeAlt7ULoZgx2srXnN7F+eRP2QM2Esi +NCubMvJIH5+hCoR64sKtlz2O1cH5VqNQ6ca0+pii7pXmKgOM3wIDAQABo4ICnzCC +ApswDgYDVR0PAQH/BAQDAgAGMBIGA1UdEwEB/wQIMAYBAf8CAQQwEQYJYIZIAYb4 +QgEBBAQDAgAHMIICYAYJYIZIAYb4QgENBIICURaCAk1GSUdZRUxFTSEgRXplbiB0 +YW51c2l0dmFueSBhIE5ldExvY2sgS2Z0LiBBbHRhbGFub3MgU3pvbGdhbHRhdGFz +aSBGZWx0ZXRlbGVpYmVuIGxlaXJ0IGVsamFyYXNvayBhbGFwamFuIGtlc3p1bHQu +IEEgaGl0ZWxlc2l0ZXMgZm9seWFtYXRhdCBhIE5ldExvY2sgS2Z0LiB0ZXJtZWtm +ZWxlbG9zc2VnLWJpenRvc2l0YXNhIHZlZGkuIEEgZGlnaXRhbGlzIGFsYWlyYXMg +ZWxmb2dhZGFzYW5hayBmZWx0ZXRlbGUgYXogZWxvaXJ0IGVsbGVub3J6ZXNpIGVs +amFyYXMgbWVndGV0ZWxlLiBBeiBlbGphcmFzIGxlaXJhc2EgbWVndGFsYWxoYXRv +IGEgTmV0TG9jayBLZnQuIEludGVybmV0IGhvbmxhcGphbiBhIGh0dHBzOi8vd3d3 +Lm5ldGxvY2submV0L2RvY3MgY2ltZW4gdmFneSBrZXJoZXRvIGF6IGVsbGVub3J6 +ZXNAbmV0bG9jay5uZXQgZS1tYWlsIGNpbWVuLiBJTVBPUlRBTlQhIFRoZSBpc3N1 +YW5jZSBhbmQgdGhlIHVzZSBvZiB0aGlzIGNlcnRpZmljYXRlIGlzIHN1YmplY3Qg +dG8gdGhlIE5ldExvY2sgQ1BTIGF2YWlsYWJsZSBhdCBodHRwczovL3d3dy5uZXRs +b2NrLm5ldC9kb2NzIG9yIGJ5IGUtbWFpbCBhdCBjcHNAbmV0bG9jay5uZXQuMA0G +CSqGSIb3DQEBBAUAA4IBAQBIJEb3ulZv+sgoA0BO5TE5ayZrU3/b39/zcT0mwBQO +xmd7I6gMc90Bu8bKbjc5VdXHjFYgDigKDtIqpLBJUsY4B/6+CgmM0ZjPytoUMaFP +0jn8DxEsQ8Pdq5PHVT5HfBgaANzze9jyf1JsIPQLX2lS9O74silg6+NJMSEN1rUQ +QeJBCWziGppWS3cC9qCbmieH6FUpccKQn0V4GuEVZD3QDtigdp+uxdAu6tYPVuxk +f1qbFFgBJ34TUMdrKuZoPL9coAob4Q566eKAw+np9v1sEZ7Q5SgnK1QyQhSCdeZK +8CtmdWOMovsEPoMOmzbwGOQmIMOM8CgHrTwXZoi1/baI +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIID5jCCAs6gAwIBAgIQV8szb8JcFuZHFhfjkDFo4DANBgkqhkiG9w0BAQUFADBi +MQswCQYDVQQGEwJVUzEhMB8GA1UEChMYTmV0d29yayBTb2x1dGlvbnMgTC5MLkMu +MTAwLgYDVQQDEydOZXR3b3JrIFNvbHV0aW9ucyBDZXJ0aWZpY2F0ZSBBdXRob3Jp +dHkwHhcNMDYxMjAxMDAwMDAwWhcNMjkxMjMxMjM1OTU5WjBiMQswCQYDVQQGEwJV +UzEhMB8GA1UEChMYTmV0d29yayBTb2x1dGlvbnMgTC5MLkMuMTAwLgYDVQQDEydO +ZXR3b3JrIFNvbHV0aW9ucyBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkwggEiMA0GCSqG +SIb3DQEBAQUAA4IBDwAwggEKAoIBAQDkvH6SMG3G2I4rC7xGzuAnlt7e+foS0zwz +c7MEL7xxjOWftiJgPl9dzgn/ggwbmlFQGiaJ3dVhXRncEg8tCqJDXRfQNJIg6nPP +OCwGJgl6cvf6UDL4wpPTaaIjzkGxzOTVHzbRijr4jGPiFFlp7Q3Tf2vouAPlT2rl +mGNpSAW+Lv8ztumXWWn4Zxmuk2GWRBXTcrA/vGp97Eh/jcOrqnErU2lBUzS1sLnF +BgrEsEX1QV1uiUV7PTsmjHTC5dLRfbIR1PtYMiKagMnc/Qzpf14Dl847ABSHJ3A4 +qY5usyd2mFHgBeMhqxrVhSI8KbWaFsWAqPS7azCPL0YCorEMIuDTAgMBAAGjgZcw +gZQwHQYDVR0OBBYEFCEwyfsA106Y2oeqKtCnLrFAMadMMA4GA1UdDwEB/wQEAwIB +BjAPBgNVHRMBAf8EBTADAQH/MFIGA1UdHwRLMEkwR6BFoEOGQWh0dHA6Ly9jcmwu +bmV0c29sc3NsLmNvbS9OZXR3b3JrU29sdXRpb25zQ2VydGlmaWNhdGVBdXRob3Jp +dHkuY3JsMA0GCSqGSIb3DQEBBQUAA4IBAQC7rkvnt1frf6ott3NHhWrB5KUd5Oc8 +6fRZZXe1eltajSU24HqXLjjAV2CDmAaDn7l2em5Q4LqILPxFzBiwmZVRDuwduIj/ +h1AcgsLj4DKAv6ALR8jDMe+ZZzKATxcheQxpXN5eNK4CtSbqUN9/GGUsyfJj4akH +/nxxH2szJGoeBfcFaMBqEssuXmHLrijTfsK0ZpEmXzwuJF/LWA/rKOyvEZbz3Htv +wKeI8lN3s2Berq4o2jUsbzRF0ybh3uxbTydrFny9RAQYgrOJeRcQcT16ohZO9QHN +pGxlaKFJdlxDydi8NmdspZS11My5vWo1ViHe2MPr+8ukYEywVaCge1ey +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIID8TCCAtmgAwIBAgIQQT1yx/RrH4FDffHSKFTfmjANBgkqhkiG9w0BAQUFADCB +ijELMAkGA1UEBhMCQ0gxEDAOBgNVBAoTB1dJU2VLZXkxGzAZBgNVBAsTEkNvcHly +aWdodCAoYykgMjAwNTEiMCAGA1UECxMZT0lTVEUgRm91bmRhdGlvbiBFbmRvcnNl +ZDEoMCYGA1UEAxMfT0lTVEUgV0lTZUtleSBHbG9iYWwgUm9vdCBHQSBDQTAeFw0w +NTEyMTExNjAzNDRaFw0zNzEyMTExNjA5NTFaMIGKMQswCQYDVQQGEwJDSDEQMA4G +A1UEChMHV0lTZUtleTEbMBkGA1UECxMSQ29weXJpZ2h0IChjKSAyMDA1MSIwIAYD +VQQLExlPSVNURSBGb3VuZGF0aW9uIEVuZG9yc2VkMSgwJgYDVQQDEx9PSVNURSBX +SVNlS2V5IEdsb2JhbCBSb290IEdBIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A +MIIBCgKCAQEAy0+zAJs9Nt350UlqaxBJH+zYK7LG+DKBKUOVTJoZIyEVRd7jyBxR +VVuuk+g3/ytr6dTqvirdqFEr12bDYVxgAsj1znJ7O7jyTmUIms2kahnBAbtzptf2 +w93NvKSLtZlhuAGio9RN1AU9ka34tAhxZK9w8RxrfvbDd50kc3vkDIzh2TbhmYsF +mQvtRTEJysIA2/dyoJaqlYfQjse2YXMNdmaM3Bu0Y6Kff5MTMPGhJ9vZ/yxViJGg +4E8HsChWjBgbl0SOid3gF27nKu+POQoxhILYQBRJLnpB5Kf+42TMwVlxSywhp1t9 +4B3RLoGbw9ho972WG6xwsRYUC9tguSYBBQIDAQABo1EwTzALBgNVHQ8EBAMCAYYw +DwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUswN+rja8sHnR3JQmthG+IbJphpQw +EAYJKwYBBAGCNxUBBAMCAQAwDQYJKoZIhvcNAQEFBQADggEBAEuh/wuHbrP5wUOx +SPMowB0uyQlB+pQAHKSkq0lPjz0e701vvbyk9vImMMkQyh2I+3QZH4VFvbBsUfk2 +ftv1TDI6QU9bR8/oCy22xBmddMVHxjtqD6wU2zz0c5ypBd8A3HR4+vg1YFkCExh8 +vPtNsCBtQ7tgMHpnM1zFmdH4LTlSc/uMqpclXHLZCB6rTjzjgTGfA6b7wP4piFXa +hNVQA7bihKOmNqoROgHhGEvWRGizPflTdISzRpFGlgC3gCy24eMQ4tui5yiPAZZi +Fj4A4xylNoEYokxSdsARo27mHbrjWr42U8U+dY+GaSlYU7Wcu2+fXMUY7N0v4ZjJ +/L7fCg0= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIJhjCCB26gAwIBAgIBCzANBgkqhkiG9w0BAQsFADCCAR4xPjA8BgNVBAMTNUF1 +dG9yaWRhZCBkZSBDZXJ0aWZpY2FjaW9uIFJhaXogZGVsIEVzdGFkbyBWZW5lem9s +YW5vMQswCQYDVQQGEwJWRTEQMA4GA1UEBxMHQ2FyYWNhczEZMBcGA1UECBMQRGlz +dHJpdG8gQ2FwaXRhbDE2MDQGA1UEChMtU2lzdGVtYSBOYWNpb25hbCBkZSBDZXJ0 +aWZpY2FjaW9uIEVsZWN0cm9uaWNhMUMwQQYDVQQLEzpTdXBlcmludGVuZGVuY2lh +IGRlIFNlcnZpY2lvcyBkZSBDZXJ0aWZpY2FjaW9uIEVsZWN0cm9uaWNhMSUwIwYJ +KoZIhvcNAQkBFhZhY3JhaXpAc3VzY2VydGUuZ29iLnZlMB4XDTEwMTIyODE2NTEw +MFoXDTIwMTIyNTIzNTk1OVowgdExJjAkBgkqhkiG9w0BCQEWF2NvbnRhY3RvQHBy +b2NlcnQubmV0LnZlMQ8wDQYDVQQHEwZDaGFjYW8xEDAOBgNVBAgTB01pcmFuZGEx +KjAoBgNVBAsTIVByb3ZlZWRvciBkZSBDZXJ0aWZpY2Fkb3MgUFJPQ0VSVDE2MDQG +A1UEChMtU2lzdGVtYSBOYWNpb25hbCBkZSBDZXJ0aWZpY2FjaW9uIEVsZWN0cm9u +aWNhMQswCQYDVQQGEwJWRTETMBEGA1UEAxMKUFNDUHJvY2VydDCCAiIwDQYJKoZI +hvcNAQEBBQADggIPADCCAgoCggIBANW39KOUM6FGqVVhSQ2oh3NekS1wwQYalNo9 +7BVCwfWMrmoX8Yqt/ICV6oNEolt6Vc5Pp6XVurgfoCfAUFM+jbnADrgV3NZs+J74 +BCXfgI8Qhd19L3uA3VcAZCP4bsm+lU/hdezgfl6VzbHvvnpC2Mks0+saGiKLt38G +ieU89RLAu9MLmV+QfI4tL3czkkohRqipCKzx9hEC2ZUWno0vluYC3XXCFCpa1sl9 +JcLB/KpnheLsvtF8PPqv1W7/U0HU9TI4seJfxPmOEO8GqQKJ/+MMbpfg353bIdD0 +PghpbNjU5Db4g7ayNo+c7zo3Fn2/omnXO1ty0K+qP1xmk6wKImG20qCZyFSTXai2 +0b1dCl53lKItwIKOvMoDKjSuc/HUtQy9vmebVOvh+qBa7Dh+PsHMosdEMXXqP+UH +0quhJZb25uSgXTcYOWEAM11G1ADEtMo88aKjPvM6/2kwLkDd9p+cJsmWN63nOaK/ +6mnbVSKVUyqUtd+tFjiBdWbjxywbk5yqjKPK2Ww8F22c3HxT4CAnQzb5EuE8XL1m +v6JpIzi4mWCZDlZTOpx+FIywBm/xhnaQr/2v/pDGj59/i5IjnOcVdo/Vi5QTcmn7 +K2FjiO/mpF7moxdqWEfLcU8UC17IAggmosvpr2uKGcfLFFb14dq12fy/czja+eev +bqQ34gcnAgMBAAGjggMXMIIDEzASBgNVHRMBAf8ECDAGAQH/AgEBMDcGA1UdEgQw +MC6CD3N1c2NlcnRlLmdvYi52ZaAbBgVghl4CAqASDBBSSUYtRy0yMDAwNDAzNi0w +MB0GA1UdDgQWBBRBDxk4qpl/Qguk1yeYVKIXTC1RVDCCAVAGA1UdIwSCAUcwggFD +gBStuyIdxuDSAaj9dlBSk+2YwU2u06GCASakggEiMIIBHjE+MDwGA1UEAxM1QXV0 +b3JpZGFkIGRlIENlcnRpZmljYWNpb24gUmFpeiBkZWwgRXN0YWRvIFZlbmV6b2xh +bm8xCzAJBgNVBAYTAlZFMRAwDgYDVQQHEwdDYXJhY2FzMRkwFwYDVQQIExBEaXN0 +cml0byBDYXBpdGFsMTYwNAYDVQQKEy1TaXN0ZW1hIE5hY2lvbmFsIGRlIENlcnRp +ZmljYWNpb24gRWxlY3Ryb25pY2ExQzBBBgNVBAsTOlN1cGVyaW50ZW5kZW5jaWEg +ZGUgU2VydmljaW9zIGRlIENlcnRpZmljYWNpb24gRWxlY3Ryb25pY2ExJTAjBgkq +hkiG9w0BCQEWFmFjcmFpekBzdXNjZXJ0ZS5nb2IudmWCAQowDgYDVR0PAQH/BAQD +AgEGME0GA1UdEQRGMESCDnByb2NlcnQubmV0LnZloBUGBWCGXgIBoAwMClBTQy0w +MDAwMDKgGwYFYIZeAgKgEgwQUklGLUotMzE2MzUzNzMtNzB2BgNVHR8EbzBtMEag +RKBChkBodHRwOi8vd3d3LnN1c2NlcnRlLmdvYi52ZS9sY3IvQ0VSVElGSUNBRE8t +UkFJWi1TSEEzODRDUkxERVIuY3JsMCOgIaAfhh1sZGFwOi8vYWNyYWl6LnN1c2Nl +cnRlLmdvYi52ZTA3BggrBgEFBQcBAQQrMCkwJwYIKwYBBQUHMAGGG2h0dHA6Ly9v +Y3NwLnN1c2NlcnRlLmdvYi52ZTBBBgNVHSAEOjA4MDYGBmCGXgMBAjAsMCoGCCsG +AQUFBwIBFh5odHRwOi8vd3d3LnN1c2NlcnRlLmdvYi52ZS9kcGMwDQYJKoZIhvcN +AQELBQADggIBACtZ6yKZu4SqT96QxtGGcSOeSwORR3C7wJJg7ODU523G0+1ng3dS +1fLld6c2suNUvtm7CpsR72H0xpkzmfWvADmNg7+mvTV+LFwxNG9s2/NkAZiqlCxB +3RWGymspThbASfzXg0gTB1GEMVKIu4YXx2sviiCtxQuPcD4quxtxj7mkoP3Yldmv +Wb8lK5jpY5MvYB7Eqvh39YtsL+1+LrVPQA3uvFd359m21D+VJzog1eWuq2w1n8Gh +HVnchIHuTQfiSLaeS5UtQbHh6N5+LwUeaO6/u5BlOsju6rEYNxxik6SgMexxbJHm +pHmJWhSnFFAFTKQAVzAswbVhltw+HoSvOULP5dAssSS830DD7X9jSr3hTxJkhpXz +sOfIt+FTvZLm8wyWuevo5pLtp4EJFAv8lXrPj9Y0TzYS3F7RNHXGRoAvlQSMx4bE +qCaJqD8Zm4G7UaRKhqsLEQ+xrmNTbSjq3TNWOByyrYDT13K9mmyZY+gAu0F2Bbdb +mRiKw7gSXFbPVgx96OLP7bx0R/vu0xdOIk9W/1DzLuY5poLWccret9W6aAjtmcz9 +opLLabid+Qqkpj5PkygqYWwHJgD/ll9ohri4zspV4KuxPX+Y1zMOWj3YeMLEYC/H +YvBhkdI4sPaeVdtAgAUSM84dkpvRabP/v/GSCmE1P93+hvS84Bpxs2Km +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIF0DCCBLigAwIBAgIEOrZQizANBgkqhkiG9w0BAQUFADB/MQswCQYDVQQGEwJC +TTEZMBcGA1UEChMQUXVvVmFkaXMgTGltaXRlZDElMCMGA1UECxMcUm9vdCBDZXJ0 +aWZpY2F0aW9uIEF1dGhvcml0eTEuMCwGA1UEAxMlUXVvVmFkaXMgUm9vdCBDZXJ0 +aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0wMTAzMTkxODMzMzNaFw0yMTAzMTcxODMz +MzNaMH8xCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBMaW1pdGVkMSUw +IwYDVQQLExxSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MS4wLAYDVQQDEyVR +dW9WYWRpcyBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIIBIjANBgkqhkiG +9w0BAQEFAAOCAQ8AMIIBCgKCAQEAv2G1lVO6V/z68mcLOhrfEYBklbTRvM16z/Yp +li4kVEAkOPcahdxYTMukJ0KX0J+DisPkBgNbAKVRHnAEdOLB1Dqr1607BxgFjv2D +rOpm2RgbaIr1VxqYuvXtdj182d6UajtLF8HVj71lODqV0D1VNk7feVcxKh7YWWVJ +WCCYfqtffp/p1k3sg3Spx2zY7ilKhSoGFPlU5tPaZQeLYzcS19Dsw3sgQUSj7cug +F+FxZc4dZjH3dgEZyH0DWLaVSR2mEiboxgx24ONmy+pdpibu5cxfvWenAScOospU +xbF6lR1xHkopigPcakXBpBlebzbNw6Kwt/5cOOJSvPhEQ+aQuwIDAQABo4ICUjCC +Ak4wPQYIKwYBBQUHAQEEMTAvMC0GCCsGAQUFBzABhiFodHRwczovL29jc3AucXVv +dmFkaXNvZmZzaG9yZS5jb20wDwYDVR0TAQH/BAUwAwEB/zCCARoGA1UdIASCAREw +ggENMIIBCQYJKwYBBAG+WAABMIH7MIHUBggrBgEFBQcCAjCBxxqBxFJlbGlhbmNl +IG9uIHRoZSBRdW9WYWRpcyBSb290IENlcnRpZmljYXRlIGJ5IGFueSBwYXJ0eSBh +c3N1bWVzIGFjY2VwdGFuY2Ugb2YgdGhlIHRoZW4gYXBwbGljYWJsZSBzdGFuZGFy +ZCB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB1c2UsIGNlcnRpZmljYXRpb24gcHJh +Y3RpY2VzLCBhbmQgdGhlIFF1b1ZhZGlzIENlcnRpZmljYXRlIFBvbGljeS4wIgYI +KwYBBQUHAgEWFmh0dHA6Ly93d3cucXVvdmFkaXMuYm0wHQYDVR0OBBYEFItLbe3T +KbkGGew5Oanwl4Rqy+/fMIGuBgNVHSMEgaYwgaOAFItLbe3TKbkGGew5Oanwl4Rq +y+/foYGEpIGBMH8xCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBMaW1p +dGVkMSUwIwYDVQQLExxSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MS4wLAYD +VQQDEyVRdW9WYWRpcyBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5ggQ6tlCL +MA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQUFAAOCAQEAitQUtf70mpKnGdSk +fnIYj9lofFIk3WdvOXrEql494liwTXCYhGHoG+NpGA7O+0dQoE7/8CQfvbLO9Sf8 +7C9TqnN7Az10buYWnuulLsS/VidQK2K6vkscPFVcQR0kvoIgR13VRH56FmjffU1R +cHhXHTMe/QKZnAzNCgVPx7uOpHX6Sm2xgI4JVrmcGmD+XcHXetwReNDWXcG31a0y +mQM6isxUJTkxgXsTIlG6Rmyhu576BGxJJnSP0nPrzDCi5upZIof4l/UO/erMkqQW +xFIY6iHOsfHmhIHluqmGKPJDWl0Snawe2ajlCmqnf6CHKc/yiU3U7MXi5nrQNiOK +SnQ2+Q== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFYDCCA0igAwIBAgIUeFhfLq0sGUvjNwc1NBMotZbUZZMwDQYJKoZIhvcNAQEL +BQAwSDELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxHjAc +BgNVBAMTFVF1b1ZhZGlzIFJvb3QgQ0EgMSBHMzAeFw0xMjAxMTIxNzI3NDRaFw00 +MjAxMTIxNzI3NDRaMEgxCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBM +aW1pdGVkMR4wHAYDVQQDExVRdW9WYWRpcyBSb290IENBIDEgRzMwggIiMA0GCSqG +SIb3DQEBAQUAA4ICDwAwggIKAoICAQCgvlAQjunybEC0BJyFuTHK3C3kEakEPBtV +wedYMB0ktMPvhd6MLOHBPd+C5k+tR4ds7FtJwUrVu4/sh6x/gpqG7D0DmVIB0jWe +rNrwU8lmPNSsAgHaJNM7qAJGr6Qc4/hzWHa39g6QDbXwz8z6+cZM5cOGMAqNF341 +68Xfuw6cwI2H44g4hWf6Pser4BOcBRiYz5P1sZK0/CPTz9XEJ0ngnjybCKOLXSoh +4Pw5qlPafX7PGglTvF0FBM+hSo+LdoINofjSxxR3W5A2B4GbPgb6Ul5jxaYA/qXp +UhtStZI5cgMJYr2wYBZupt0lwgNm3fME0UDiTouG9G/lg6AnhF4EwfWQvTA9xO+o +abw4m6SkltFi2mnAAZauy8RRNOoMqv8hjlmPSlzkYZqn0ukqeI1RPToV7qJZjqlc +3sX5kCLliEVx3ZGZbHqfPT2YfF72vhZooF6uCyP8Wg+qInYtyaEQHeTTRCOQiJ/G +KubX9ZqzWB4vMIkIG1SitZgj7Ah3HJVdYdHLiZxfokqRmu8hqkkWCKi9YSgxyXSt +hfbZxbGL0eUQMk1fiyA6PEkfM4VZDdvLCXVDaXP7a3F98N/ETH3Goy7IlXnLc6KO +Tk0k+17kBL5yG6YnLUlamXrXXAkgt3+UuU/xDRxeiEIbEbfnkduebPRq34wGmAOt +zCjvpUfzUwIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB +BjAdBgNVHQ4EFgQUo5fW816iEOGrRZ88F2Q87gFwnMwwDQYJKoZIhvcNAQELBQAD +ggIBABj6W3X8PnrHX3fHyt/PX8MSxEBd1DKquGrX1RUVRpgjpeaQWxiZTOOtQqOC +MTaIzen7xASWSIsBx40Bz1szBpZGZnQdT+3Btrm0DWHMY37XLneMlhwqI2hrhVd2 +cDMT/uFPpiN3GPoajOi9ZcnPP/TJF9zrx7zABC4tRi9pZsMbj/7sPtPKlL92CiUN +qXsCHKnQO18LwIE6PWThv6ctTr1NxNgpxiIY0MWscgKCP6o6ojoilzHdCGPDdRS5 +YCgtW2jgFqlmgiNR9etT2DGbe+m3nUvriBbP+V04ikkwj+3x6xn0dxoxGE1nVGwv +b2X52z3sIexe9PSLymBlVNFxZPT5pqOBMzYzcfCkeF9OrYMh3jRJjehZrJ3ydlo2 +8hP0r+AJx2EqbPfgna67hkooby7utHnNkDPDs3b69fBsnQGQ+p6Q9pxyz0fawx/k +NSBT8lTR32GDpgLiJTjehTItXnOQUl1CxM49S+H5GYQd1aJQzEH7QRTDvdbJWqNj +ZgKAvQU6O0ec7AAmTPWIUb+oI38YB7AL7YsmoWTTYUrrXJ/es69nA7Mf3W1daWhp +q1467HxpvMc7hU6eFbm0FU/DlXpY18ls6Wy58yljXrQs8C097Vpl4KlbQMJImYFt +nh8GKjwStIsPm6Ik8KaN1nrgS7ZklmOVhMJKzRwuJIczYOXD +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFtzCCA5+gAwIBAgICBQkwDQYJKoZIhvcNAQEFBQAwRTELMAkGA1UEBhMCQk0x +GTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxGzAZBgNVBAMTElF1b1ZhZGlzIFJv +b3QgQ0EgMjAeFw0wNjExMjQxODI3MDBaFw0zMTExMjQxODIzMzNaMEUxCzAJBgNV +BAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBMaW1pdGVkMRswGQYDVQQDExJRdW9W +YWRpcyBSb290IENBIDIwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCa +GMpLlA0ALa8DKYrwD4HIrkwZhR0In6spRIXzL4GtMh6QRr+jhiYaHv5+HBg6XJxg +Fyo6dIMzMH1hVBHL7avg5tKifvVrbxi3Cgst/ek+7wrGsxDp3MJGF/hd/aTa/55J +WpzmM+Yklvc/ulsrHHo1wtZn/qtmUIttKGAr79dgw8eTvI02kfN/+NsRE8Scd3bB +rrcCaoF6qUWD4gXmuVbBlDePSHFjIuwXZQeVikvfj8ZaCuWw419eaxGrDPmF60Tp ++ARz8un+XJiM9XOva7R+zdRcAitMOeGylZUtQofX1bOQQ7dsE/He3fbE+Ik/0XX1 +ksOR1YqI0JDs3G3eicJlcZaLDQP9nL9bFqyS2+r+eXyt66/3FsvbzSUr5R/7mp/i +Ucw6UwxI5g69ybR2BlLmEROFcmMDBOAENisgGQLodKcftslWZvB1JdxnwQ5hYIiz +PtGo/KPaHbDRsSNU30R2be1B2MGyIrZTHN81Hdyhdyox5C315eXbyOD/5YDXC2Og +/zOhD7osFRXql7PSorW+8oyWHhqPHWykYTe5hnMz15eWniN9gqRMgeKh0bpnX5UH +oycR7hYQe7xFSkyyBNKr79X9DFHOUGoIMfmR2gyPZFwDwzqLID9ujWc9Otb+fVuI +yV77zGHcizN300QyNQliBJIWENieJ0f7OyHj+OsdWwIDAQABo4GwMIGtMA8GA1Ud +EwEB/wQFMAMBAf8wCwYDVR0PBAQDAgEGMB0GA1UdDgQWBBQahGK8SEwzJQTU7tD2 +A8QZRtGUazBuBgNVHSMEZzBlgBQahGK8SEwzJQTU7tD2A8QZRtGUa6FJpEcwRTEL +MAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxGzAZBgNVBAMT +ElF1b1ZhZGlzIFJvb3QgQ0EgMoICBQkwDQYJKoZIhvcNAQEFBQADggIBAD4KFk2f +BluornFdLwUvZ+YTRYPENvbzwCYMDbVHZF34tHLJRqUDGCdViXh9duqWNIAXINzn +g/iN/Ae42l9NLmeyhP3ZRPx3UIHmfLTJDQtyU/h2BwdBR5YM++CCJpNVjP4iH2Bl +fF/nJrP3MpCYUNQ3cVX2kiF495V5+vgtJodmVjB3pjd4M1IQWK4/YY7yarHvGH5K +WWPKjaJW1acvvFYfzznB4vsKqBUsfU16Y8Zsl0Q80m/DShcK+JDSV6IZUaUtl0Ha +B0+pUNqQjZRG4T7wlP0QADj1O+hA4bRuVhogzG9Yje0uRY/W6ZM/57Es3zrWIozc +hLsib9D45MY56QSIPMO661V6bYCZJPVsAfv4l7CUW+v90m/xd2gNNWQjrLhVoQPR +TUIZ3Ph1WVaj+ahJefivDrkRoHy3au000LYmYjgahwz46P0u05B/B5EqHdZ+XIWD +mbA4CD/pXvk1B+TJYm5Xf6dQlfe6yJvmjqIBxdZmv3lh8zwc4bmCXF2gw+nYSL0Z +ohEUGW6yhhtoPkg3Goi3XZZenMfvJ2II4pEZXNLxId26F0KCl3GBUzGpn/Z9Yr9y +4aOTHcyKJloJONDO1w2AFrR4pTqHTI2KpdVGl/IsELm8VCLAAVBpQ570su9t+Oza +8eOx79+Rj1QqCyXBJhnEUhAFZdWCEOrCMc0u +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFYDCCA0igAwIBAgIURFc0JFuBiZs18s64KztbpybwdSgwDQYJKoZIhvcNAQEL +BQAwSDELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxHjAc +BgNVBAMTFVF1b1ZhZGlzIFJvb3QgQ0EgMiBHMzAeFw0xMjAxMTIxODU5MzJaFw00 +MjAxMTIxODU5MzJaMEgxCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBM +aW1pdGVkMR4wHAYDVQQDExVRdW9WYWRpcyBSb290IENBIDIgRzMwggIiMA0GCSqG +SIb3DQEBAQUAA4ICDwAwggIKAoICAQChriWyARjcV4g/Ruv5r+LrI3HimtFhZiFf +qq8nUeVuGxbULX1QsFN3vXg6YOJkApt8hpvWGo6t/x8Vf9WVHhLL5hSEBMHfNrMW +n4rjyduYNM7YMxcoRvynyfDStNVNCXJJ+fKH46nafaF9a7I6JaltUkSs+L5u+9ym +c5GQYaYDFCDy54ejiK2toIz/pgslUiXnFgHVy7g1gQyjO/Dh4fxaXc6AcW34Sas+ +O7q414AB+6XrW7PFXmAqMaCvN+ggOp+oMiwMzAkd056OXbxMmO7FGmh77FOm6RQ1 +o9/NgJ8MSPsc9PG/Srj61YxxSscfrf5BmrODXfKEVu+lV0POKa2Mq1W/xPtbAd0j +IaFYAI7D0GoT7RPjEiuA3GfmlbLNHiJuKvhB1PLKFAeNilUSxmn1uIZoL1NesNKq +IcGY5jDjZ1XHm26sGahVpkUG0CM62+tlXSoREfA7T8pt9DTEceT/AFr2XK4jYIVz +8eQQsSWu1ZK7E8EM4DnatDlXtas1qnIhO4M15zHfeiFuuDIIfR0ykRVKYnLP43eh +vNURG3YBZwjgQQvD6xVu+KQZ2aKrr+InUlYrAoosFCT5v0ICvybIxo/gbjh9Uy3l +7ZizlWNof/k19N+IxWA1ksB8aRxhlRbQ694Lrz4EEEVlWFA4r0jyWbYW8jwNkALG +cC4BrTwV1wIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB +BjAdBgNVHQ4EFgQU7edvdlq/YOxJW8ald7tyFnGbxD0wDQYJKoZIhvcNAQELBQAD +ggIBAJHfgD9DCX5xwvfrs4iP4VGyvD11+ShdyLyZm3tdquXK4Qr36LLTn91nMX66 +AarHakE7kNQIXLJgapDwyM4DYvmL7ftuKtwGTTwpD4kWilhMSA/ohGHqPHKmd+RC +roijQ1h5fq7KpVMNqT1wvSAZYaRsOPxDMuHBR//47PERIjKWnML2W2mWeyAMQ0Ga +W/ZZGYjeVYg3UQt4XAoeo0L9x52ID8DyeAIkVJOviYeIyUqAHerQbj5hLja7NQ4n +lv1mNDthcnPxFlxHBlRJAHpYErAK74X9sbgzdWqTHBLmYF5vHX/JHyPLhGGfHoJE ++V+tYlUkmlKY7VHnoX6XOuYvHxHaU4AshZ6rNRDbIl9qxV6XU/IyAgkwo1jwDQHV +csaxfGl7w/U2Rcxhbl5MlMVerugOXou/983g7aEOGzPuVBj+D77vfoRrQ+NwmNtd +dbINWQeFFSM51vHfqSYP1kjHs6Yi9TM3WpVHn3u6GBVv/9YUZINJ0gpnIdsPNWNg +KCLjsZWDzYWm3S8P52dSbrsvhXz1SnPnxT7AvSESBT/8twNJAlvIJebiVDj1eYeM +HVOyToV7BjjHLPj4sHKNJeV3UvQDHEimUF+IIDBu8oJDqz2XhOdT+yHBTw8imoa4 +WSr2Rz0ZiC3oheGe7IUIarFsNMkd7EgrO3jtZsSOeWmD3n+M +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIGnTCCBIWgAwIBAgICBcYwDQYJKoZIhvcNAQEFBQAwRTELMAkGA1UEBhMCQk0x +GTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxGzAZBgNVBAMTElF1b1ZhZGlzIFJv +b3QgQ0EgMzAeFw0wNjExMjQxOTExMjNaFw0zMTExMjQxOTA2NDRaMEUxCzAJBgNV +BAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBMaW1pdGVkMRswGQYDVQQDExJRdW9W +YWRpcyBSb290IENBIDMwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDM +V0IWVJzmmNPTTe7+7cefQzlKZbPoFog02w1ZkXTPkrgEQK0CSzGrvI2RaNggDhoB +4hp7Thdd4oq3P5kazethq8Jlph+3t723j/z9cI8LoGe+AaJZz3HmDyl2/7FWeUUr +H556VOijKTVopAFPD6QuN+8bv+OPEKhyq1hX51SGyMnzW9os2l2ObjyjPtr7guXd +8lyyBTNvijbO0BNO/79KDDRMpsMhvVAEVeuxu537RR5kFd5VAYwCdrXLoT9Cabwv +vWhDFlaJKjdhkf2mrk7AyxRllDdLkgbvBNDInIjbC3uBr7E9KsRlOni27tyAsdLT +mZw67mtaa7ONt9XOnMK+pUsvFrGeaDsGb659n/je7Mwpp5ijJUMv7/FfJuGITfhe +btfZFG4ZM2mnO4SJk8RTVROhUXhA+LjJou57ulJCg54U7QVSWllWp5f8nT8KKdjc +T5EOE7zelaTfi5m+rJsziO+1ga8bxiJTyPbH7pcUsMV8eFLI8M5ud2CEpukqdiDt +WAEXMJPpGovgc2PZapKUSU60rUqFxKMiMPwJ7Wgic6aIDFUhWMXhOp8q3crhkODZ +c6tsgLjoC2SToJyMGf+z0gzskSaHirOi4XCPLArlzW1oUevaPwV/izLmE1xr/l9A +4iLItLRkT9a6fUg+qGkM17uGcclzuD87nSVL2v9A6wIDAQABo4IBlTCCAZEwDwYD +VR0TAQH/BAUwAwEB/zCB4QYDVR0gBIHZMIHWMIHTBgkrBgEEAb5YAAMwgcUwgZMG +CCsGAQUFBwICMIGGGoGDQW55IHVzZSBvZiB0aGlzIENlcnRpZmljYXRlIGNvbnN0 +aXR1dGVzIGFjY2VwdGFuY2Ugb2YgdGhlIFF1b1ZhZGlzIFJvb3QgQ0EgMyBDZXJ0 +aWZpY2F0ZSBQb2xpY3kgLyBDZXJ0aWZpY2F0aW9uIFByYWN0aWNlIFN0YXRlbWVu +dC4wLQYIKwYBBQUHAgEWIWh0dHA6Ly93d3cucXVvdmFkaXNnbG9iYWwuY29tL2Nw +czALBgNVHQ8EBAMCAQYwHQYDVR0OBBYEFPLAE+CCQz777i9nMpY1XNu4ywLQMG4G +A1UdIwRnMGWAFPLAE+CCQz777i9nMpY1XNu4ywLQoUmkRzBFMQswCQYDVQQGEwJC +TTEZMBcGA1UEChMQUXVvVmFkaXMgTGltaXRlZDEbMBkGA1UEAxMSUXVvVmFkaXMg +Um9vdCBDQSAzggIFxjANBgkqhkiG9w0BAQUFAAOCAgEAT62gLEz6wPJv92ZVqyM0 +7ucp2sNbtrCD2dDQ4iH782CnO11gUyeim/YIIirnv6By5ZwkajGxkHon24QRiSem +d1o417+shvzuXYO8BsbRd2sPbSQvS3pspweWyuOEn62Iix2rFo1bZhfZFvSLgNLd ++LJ2w/w4E6oM3kJpK27zPOuAJ9v1pkQNn1pVWQvVDVJIxa6f8i+AxeoyUDUSly7B +4f/xI4hROJ/yZlZ25w9Rl6VSDE1JUZU2Pb+iSwwQHYaZTKrzchGT5Or2m9qoXadN +t54CrnMAyNojA+j56hl0YgCUyyIgvpSnWbWCar6ZeXqp8kokUvd0/bpO5qgdAm6x +DYBEwa7TIzdfu4V8K5Iu6H6li92Z4b8nby1dqnuH/grdS/yO9SbkbnBCbjPsMZ57 +k8HkyWkaPcBrTiJt7qtYTcbQQcEr6k8Sh17rRdhs9ZgC06DYVYoGmRmioHfRMJ6s +zHXug/WwYjnPbFfiTNKRCw51KBuav/0aQ/HKd/s7j2G4aSgWQgRecCocIdiP4b0j +Wy10QJLZYxkNc91pvGJHvOB0K7Lrfb5BG7XARsWhIstfTsEokt4YutUqKLsRixeT +mJlglFwjz1onl14LBQaTNx47aTbrqZ5hHY8y2o4M1nQ+ewkk2gF3R8Q7zTSMmfXK +4SVhM7JZG+Ju1zdXtg2pEto= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFYDCCA0igAwIBAgIULvWbAiin23r/1aOp7r0DoM8Sah0wDQYJKoZIhvcNAQEL +BQAwSDELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxHjAc +BgNVBAMTFVF1b1ZhZGlzIFJvb3QgQ0EgMyBHMzAeFw0xMjAxMTIyMDI2MzJaFw00 +MjAxMTIyMDI2MzJaMEgxCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBM +aW1pdGVkMR4wHAYDVQQDExVRdW9WYWRpcyBSb290IENBIDMgRzMwggIiMA0GCSqG +SIb3DQEBAQUAA4ICDwAwggIKAoICAQCzyw4QZ47qFJenMioKVjZ/aEzHs286IxSR +/xl/pcqs7rN2nXrpixurazHb+gtTTK/FpRp5PIpM/6zfJd5O2YIyC0TeytuMrKNu +FoM7pmRLMon7FhY4futD4tN0SsJiCnMK3UmzV9KwCoWdcTzeo8vAMvMBOSBDGzXR +U7Ox7sWTaYI+FrUoRqHe6okJ7UO4BUaKhvVZR74bbwEhELn9qdIoyhA5CcoTNs+c +ra1AdHkrAj80//ogaX3T7mH1urPnMNA3I4ZyYUUpSFlob3emLoG+B01vr87ERROR +FHAGjx+f+IdpsQ7vw4kZ6+ocYfx6bIrc1gMLnia6Et3UVDmrJqMz6nWB2i3ND0/k +A9HvFZcba5DFApCTZgIhsUfei5pKgLlVj7WiL8DWM2fafsSntARE60f75li59wzw +eyuxwHApw0BiLTtIadwjPEjrewl5qW3aqDCYz4ByA4imW0aucnl8CAMhZa634Ryl +sSqiMd5mBPfAdOhx3v89WcyWJhKLhZVXGqtrdQtEPREoPHtht+KPZ0/l7DxMYIBp +VzgeAVuNVejH38DMdyM0SXV89pgR6y3e7UEuFAUCf+D+IOs15xGsIs5XPd7JMG0Q +A4XN8f+MFrXBsj6IbGB/kE+V9/YtrQE5BwT6dYB9v0lQ7e/JxHwc64B+27bQ3RP+ +ydOc17KXqQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB +BjAdBgNVHQ4EFgQUxhfQvKjqAkPyGwaZXSuQILnXnOQwDQYJKoZIhvcNAQELBQAD +ggIBADRh2Va1EodVTd2jNTFGu6QHcrxfYWLopfsLN7E8trP6KZ1/AvWkyaiTt3px +KGmPc+FSkNrVvjrlt3ZqVoAh313m6Tqe5T72omnHKgqwGEfcIHB9UqM+WXzBusnI +FUBhynLWcKzSt/Ac5IYp8M7vaGPQtSCKFWGafoaYtMnCdvvMujAWzKNhxnQT5Wvv +oxXqA/4Ti2Tk08HS6IT7SdEQTXlm66r99I0xHnAUrdzeZxNMgRVhvLfZkXdxGYFg +u/BYpbWcC/ePIlUnwEsBbTuZDdQdm2NnL9DuDcpmvJRPpq3t/O5jrFc/ZSXPsoaP +0Aj/uHYUbt7lJ+yreLVTubY/6CD50qi+YUbKh4yE8/nxoGibIh6BJpsQBJFxwAYf +3KDTuVan45gtf4Od34wrnDKOMpTwATwiKp9Dwi7DmDkHOHv8XgBCH/MyJnmDhPbl +8MFREsALHgQjDFSlTC9JxUrRtm5gDWv8a4uFJGS3iQ6rJUdbPM9+Sb3H6QrG2vd+ +DhcI00iX0HGS8A85PjRqHH3Y8iKuu2n0M7SmSFXRDw4m6Oy2Cy2nhTXN/VnIn9HN +PlopNLk9hM6xZdRZkZFWdSHBd575euFgndOtBBj0fOtek49TSiIp+EgrPk2GrFt/ +ywaZWWDYWGWVjUTR939+J399roD1B0y2PpxxVJkES/1Y+Zj0 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIC5zCCAlACAQEwDQYJKoZIhvcNAQEFBQAwgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0 +IFZhbGlkYXRpb24gTmV0d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAz +BgNVBAsTLFZhbGlDZXJ0IENsYXNzIDMgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9y +aXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG +9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMB4XDTk5MDYyNjAwMjIzM1oXDTE5MDYy +NjAwMjIzM1owgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0IFZhbGlkYXRpb24gTmV0d29y +azEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENs +YXNzIDMgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9yaXR5MSEwHwYDVQQDExhodHRw +Oi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG9w0BCQEWEWluZm9AdmFsaWNl +cnQuY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDjmFGWHOjVsQaBalfD +cnWTq8+epvzzFlLWLU2fNUSoLgRNB0mKOCn1dzfnt6td3zZxFJmP3MKS8edgkpfs +2Ejcv8ECIMYkpChMMFp2bbFc893enhBxoYjHW5tBbcqwuI4V7q0zK89HBFx1cQqY +JJgpp0lZpd34t0NiYfPT4tBVPwIDAQABMA0GCSqGSIb3DQEBBQUAA4GBAFa7AliE +Zwgs3x/be0kz9dNnnfS0ChCzycUs4pJqcXgn8nCDQtM+z6lU9PHYkhaM0QTLS6vJ +n0WuPIqpsHEzXcjFV9+vqDWzf4mH6eglkrh/hXqu1rweN1gqZ8mRzyqBPu3GOd/A +PhmcGcwTTYJBtYze4D1gCCAPRX5ron+jjBXu +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDYTCCAkmgAwIBAgIQCgEBAQAAAnwAAAAKAAAAAjANBgkqhkiG9w0BAQUFADA6 +MRkwFwYDVQQKExBSU0EgU2VjdXJpdHkgSW5jMR0wGwYDVQQLExRSU0EgU2VjdXJp +dHkgMjA0OCBWMzAeFw0wMTAyMjIyMDM5MjNaFw0yNjAyMjIyMDM5MjNaMDoxGTAX +BgNVBAoTEFJTQSBTZWN1cml0eSBJbmMxHTAbBgNVBAsTFFJTQSBTZWN1cml0eSAy +MDQ4IFYzMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAt49VcdKA3Xtp +eafwGFAyPGJn9gqVB93mG/Oe2dJBVGutn3y+Gc37RqtBaB4Y6lXIL5F4iSj7Jylg +/9+PjDvJSZu1pJTOAeo+tWN7fyb9Gd3AIb2E0S1PRsNO3Ng3OTsor8udGuorryGl +wSMiuLgbWhOHV4PR8CDn6E8jQrAApX2J6elhc5SYcSa8LWrg903w8bYqODGBDSnh +AMFRD0xS+ARaqn1y07iHKrtjEAMqs6FPDVpeRrc9DvV07Jmf+T0kgYim3WBU6JU2 +PcYJk5qjEoAAVZkZR73QpXzDuvsf9/UP+Ky5tfQ3mBMY3oVbtwyCO4dvlTlYMNpu +AWgXIszACwIDAQABo2MwYTAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB +BjAfBgNVHSMEGDAWgBQHw1EwpKrpRa41JPr/JCwz0LGdjDAdBgNVHQ4EFgQUB8NR +MKSq6UWuNST6/yQsM9CxnYwwDQYJKoZIhvcNAQEFBQADggEBAF8+hnZuuDU8TjYc +HnmYv/3VEhF5Ug7uMYm83X/50cYVIeiKAVQNOvtUudZj1LGqlk2iQk3UUx+LEN5/ +Zb5gEydxiKRz44Rj0aRV4VCT5hsOedBnvEbIvz8XDZXmxpBp3ue0L96VfdASPz0+ +f00/FGj1EVDVwfSQpQgdMWD/YIwjVAqv/qFuxdF6Kmh4zx6CCiC0H63lhbJqaHVO +rSU3lIW+vaHU6rcMSzyd6BIA8F+sDeGscGNz9395nzIlQnQFgCi/vcEkllgVsRch +6YlL2weIZ/QVrXA+L02FO8K32/6YaCOJ4XQP3vTFhGMpG8zLB8kApKnXwiJPZ9d3 +7CAFYd4= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIGizCCBXOgAwIBAgIEO0XlaDANBgkqhkiG9w0BAQUFADBoMQswCQYDVQQGEwJF +UzEfMB0GA1UEChMWR2VuZXJhbGl0YXQgVmFsZW5jaWFuYTEPMA0GA1UECxMGUEtJ +R1ZBMScwJQYDVQQDEx5Sb290IENBIEdlbmVyYWxpdGF0IFZhbGVuY2lhbmEwHhcN +MDEwNzA2MTYyMjQ3WhcNMjEwNzAxMTUyMjQ3WjBoMQswCQYDVQQGEwJFUzEfMB0G +A1UEChMWR2VuZXJhbGl0YXQgVmFsZW5jaWFuYTEPMA0GA1UECxMGUEtJR1ZBMScw +JQYDVQQDEx5Sb290IENBIEdlbmVyYWxpdGF0IFZhbGVuY2lhbmEwggEiMA0GCSqG +SIb3DQEBAQUAA4IBDwAwggEKAoIBAQDGKqtXETcvIorKA3Qdyu0togu8M1JAJke+ +WmmmO3I2F0zo37i7L3bhQEZ0ZQKQUgi0/6iMweDHiVYQOTPvaLRfX9ptI6GJXiKj +SgbwJ/BXufjpTjJ3Cj9BZPPrZe52/lSqfR0grvPXdMIKX/UIKFIIzFVd0g/bmoGl +u6GzwZTNVOAydTGRGmKy3nXiz0+J2ZGQD0EbtFpKd71ng+CT516nDOeB0/RSrFOy +A8dEJvt55cs0YFAQexvba9dHq198aMpunUEDEO5rmXteJajCq+TA81yc477OMUxk +Hl6AovWDfgzWyoxVjr7gvkkHD6MkQXpYHYTqWBLI4bft75PelAgxAgMBAAGjggM7 +MIIDNzAyBggrBgEFBQcBAQQmMCQwIgYIKwYBBQUHMAGGFmh0dHA6Ly9vY3NwLnBr +aS5ndmEuZXMwEgYDVR0TAQH/BAgwBgEB/wIBAjCCAjQGA1UdIASCAiswggInMIIC +IwYKKwYBBAG/VQIBADCCAhMwggHoBggrBgEFBQcCAjCCAdoeggHWAEEAdQB0AG8A +cgBpAGQAYQBkACAAZABlACAAQwBlAHIAdABpAGYAaQBjAGEAYwBpAPMAbgAgAFIA +YQDtAHoAIABkAGUAIABsAGEAIABHAGUAbgBlAHIAYQBsAGkAdABhAHQAIABWAGEA +bABlAG4AYwBpAGEAbgBhAC4ADQAKAEwAYQAgAEQAZQBjAGwAYQByAGEAYwBpAPMA +bgAgAGQAZQAgAFAAcgDhAGMAdABpAGMAYQBzACAAZABlACAAQwBlAHIAdABpAGYA +aQBjAGEAYwBpAPMAbgAgAHEAdQBlACAAcgBpAGcAZQAgAGUAbAAgAGYAdQBuAGMA +aQBvAG4AYQBtAGkAZQBuAHQAbwAgAGQAZQAgAGwAYQAgAHAAcgBlAHMAZQBuAHQA +ZQAgAEEAdQB0AG8AcgBpAGQAYQBkACAAZABlACAAQwBlAHIAdABpAGYAaQBjAGEA +YwBpAPMAbgAgAHMAZQAgAGUAbgBjAHUAZQBuAHQAcgBhACAAZQBuACAAbABhACAA +ZABpAHIAZQBjAGMAaQDzAG4AIAB3AGUAYgAgAGgAdAB0AHAAOgAvAC8AdwB3AHcA +LgBwAGsAaQAuAGcAdgBhAC4AZQBzAC8AYwBwAHMwJQYIKwYBBQUHAgEWGWh0dHA6 +Ly93d3cucGtpLmd2YS5lcy9jcHMwHQYDVR0OBBYEFHs100DSHHgZZu90ECjcPk+y +eAT8MIGVBgNVHSMEgY0wgYqAFHs100DSHHgZZu90ECjcPk+yeAT8oWykajBoMQsw +CQYDVQQGEwJFUzEfMB0GA1UEChMWR2VuZXJhbGl0YXQgVmFsZW5jaWFuYTEPMA0G +A1UECxMGUEtJR1ZBMScwJQYDVQQDEx5Sb290IENBIEdlbmVyYWxpdGF0IFZhbGVu +Y2lhbmGCBDtF5WgwDQYJKoZIhvcNAQEFBQADggEBACRhTvW1yEICKrNcda3Fbcrn +lD+laJWIwVTAEGmiEi8YPyVQqHxK6sYJ2fR1xkDar1CdPaUWu20xxsdzCkj+IHLt +b8zog2EWRpABlUt9jppSCS/2bxzkoXHPjCpaF3ODR00PNvsETUlR4hTJZGH71BTg +9J63NI8KJr2XXPR5OkowGcytT6CYirQxlyric21+eLj4iIlPsSKRZEv1UN4D2+XF +ducTZnV+ZfsBn5OHiJ35Rld8TWCvmHMTI6QgkYH60GFmuH3Rr9ZvHmw96RH9qfmC +IoaZM3Fa6hlXPZHNqcCjbgcTpsnt+GijnsNacgmHKNHEc8RzGF9QdRYxn7fofMM= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDbTCCAlWgAwIBAgIBATANBgkqhkiG9w0BAQUFADBYMQswCQYDVQQGEwJKUDEr +MCkGA1UEChMiSmFwYW4gQ2VydGlmaWNhdGlvbiBTZXJ2aWNlcywgSW5jLjEcMBoG +A1UEAxMTU2VjdXJlU2lnbiBSb290Q0ExMTAeFw0wOTA0MDgwNDU2NDdaFw0yOTA0 +MDgwNDU2NDdaMFgxCzAJBgNVBAYTAkpQMSswKQYDVQQKEyJKYXBhbiBDZXJ0aWZp +Y2F0aW9uIFNlcnZpY2VzLCBJbmMuMRwwGgYDVQQDExNTZWN1cmVTaWduIFJvb3RD +QTExMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA/XeqpRyQBTvLTJsz +i1oURaTnkBbR31fSIRCkF/3frNYfp+TbfPfs37gD2pRY/V1yfIw/XwFndBWW4wI8 +h9uuywGOwvNmxoVF9ALGOrVisq/6nL+k5tSAMJjzDbaTj6nU2DbysPyKyiyhFTOV +MdrAG/LuYpmGYz+/3ZMqg6h2uRMft85OQoWPIucuGvKVCbIFtUROd6EgvanyTgp9 +UK31BQ1FT0Zx/Sg+U/sE2C3XZR1KG/rPO7AxmjVuyIsG0wCR8pQIZUyxNAYAeoni +8McDWc/V1uinMrPmmECGxc0nEovMe863ETxiYAcjPitAbpSACW22s293bzUIUPsC +h8U+iQIDAQABo0IwQDAdBgNVHQ4EFgQUW/hNT7KlhtQ60vFjmqC+CfZXt94wDgYD +VR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEFBQADggEB +AKChOBZmLqdWHyGcBvod7bkixTgm2E5P7KN/ed5GIaGHd48HCJqypMWvDzKYC3xm +KbabfSVSSUOrTC4rbnpwrxYO4wJs+0LmGJ1F2FXI6Dvd5+H0LgscNFxsWEr7jIhQ +X5Ucv+2rIrVls4W6ng+4reV6G4pQOh29Dbx7VFALuUKvVaAYga1lme++5Jy/xIWr +QbJUb9wlze144o4MjQlJ3WN7WmmWAiGovVJZ6X01y8hSyn+B/tlr0/cR7SXf+Of5 +pPpyl4RTDaXQMhhRdlkUbA/r7F+AjHVDg8OFmP9Mni0N5HeDk061lgeLKBObjBmN +QSdJQO7e5iNEOdyhIta6A/I= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDuDCCAqCgAwIBAgIQDPCOXAgWpa1Cf/DrJxhZ0DANBgkqhkiG9w0BAQUFADBI +MQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3QgQ29ycG9yYXRpb24x +FzAVBgNVBAMTDlNlY3VyZVRydXN0IENBMB4XDTA2MTEwNzE5MzExOFoXDTI5MTIz +MTE5NDA1NVowSDELMAkGA1UEBhMCVVMxIDAeBgNVBAoTF1NlY3VyZVRydXN0IENv +cnBvcmF0aW9uMRcwFQYDVQQDEw5TZWN1cmVUcnVzdCBDQTCCASIwDQYJKoZIhvcN +AQEBBQADggEPADCCAQoCggEBAKukgeWVzfX2FI7CT8rU4niVWJxB4Q2ZQCQXOZEz +Zum+4YOvYlyJ0fwkW2Gz4BERQRwdbvC4u/jep4G6pkjGnx29vo6pQT64lO0pGtSO +0gMdA+9tDWccV9cGrcrI9f4Or2YlSASWC12juhbDCE/RRvgUXPLIXgGZbf2IzIao +wW8xQmxSPmjL8xk037uHGFaAJsTQ3MBv396gwpEWoGQRS0S8Hvbn+mPeZqx2pHGj +7DaUaHp3pLHnDi+BeuK1cobvomuL8A/b01k/unK8RCSc43Oz969XL0Imnal0ugBS +8kvNU3xHCzaFDmapCJcWNFfBZveA4+1wVMeT4C4oFVmHursCAwEAAaOBnTCBmjAT +BgkrBgEEAYI3FAIEBh4EAEMAQTALBgNVHQ8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB +/zAdBgNVHQ4EFgQUQjK2FvoE/f5dS3rD/fdMQB1aQ68wNAYDVR0fBC0wKzApoCeg +JYYjaHR0cDovL2NybC5zZWN1cmV0cnVzdC5jb20vU1RDQS5jcmwwEAYJKwYBBAGC +NxUBBAMCAQAwDQYJKoZIhvcNAQEFBQADggEBADDtT0rhWDpSclu1pqNlGKa7UTt3 +6Z3q059c4EVlew3KW+JwULKUBRSuSceNQQcSc5R+DCMh/bwQf2AQWnL1mA6s7Ll/ +3XpvXdMc9P+IBWlCqQVxyLesJugutIxq/3HcuLHfmbx8IVQr5Fiiu1cprp6poxkm +D5kuCLDv/WnPmRoJjeOnnyvJNjR7JLN4TJUXpAYmHrZkUjZfYGfZnMUFdAvnZyPS +CPyI6a6Lf+Ew9Dd+/cYy2i2eRDAwbO4H3tI0/NL/QPZL9GZGBlSm8jIKYyYwa5vR +3ItHuuG51WLQoqD0ZwV4KWMabwTW+MZMo5qxN7SN5ShLHZ4swrhovO0C7jE= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDvDCCAqSgAwIBAgIQB1YipOjUiolN9BPI8PjqpTANBgkqhkiG9w0BAQUFADBK +MQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3QgQ29ycG9yYXRpb24x +GTAXBgNVBAMTEFNlY3VyZSBHbG9iYWwgQ0EwHhcNMDYxMTA3MTk0MjI4WhcNMjkx +MjMxMTk1MjA2WjBKMQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3Qg +Q29ycG9yYXRpb24xGTAXBgNVBAMTEFNlY3VyZSBHbG9iYWwgQ0EwggEiMA0GCSqG +SIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvNS7YrGxVaQZx5RNoJLNP2MwhR/jxYDiJ +iQPpvepeRlMJ3Fz1Wuj3RSoC6zFh1ykzTM7HfAo3fg+6MpjhHZevj8fcyTiW89sa +/FHtaMbQbqR8JNGuQsiWUGMu4P51/pinX0kuleM5M2SOHqRfkNJnPLLZ/kG5VacJ +jnIFHovdRIWCQtBJwB1g8NEXLJXr9qXBkqPFwqcIYA1gBBCWeZ4WNOaptvolRTnI +HmX5k/Wq8VLcmZg9pYYaDDUz+kulBAYVHDGA76oYa8J719rO+TMg1fW9ajMtgQT7 +sFzUnKPiXB3jqUJ1XnvUd+85VLrJChgbEplJL4hL/VBi0XPnj3pDAgMBAAGjgZ0w +gZowEwYJKwYBBAGCNxQCBAYeBABDAEEwCwYDVR0PBAQDAgGGMA8GA1UdEwEB/wQF +MAMBAf8wHQYDVR0OBBYEFK9EBMJBfkiD2045AuzshHrmzsmkMDQGA1UdHwQtMCsw +KaAnoCWGI2h0dHA6Ly9jcmwuc2VjdXJldHJ1c3QuY29tL1NHQ0EuY3JsMBAGCSsG +AQQBgjcVAQQDAgEAMA0GCSqGSIb3DQEBBQUAA4IBAQBjGghAfaReUw132HquHw0L +URYD7xh8yOOvaliTFGCRsoTciE6+OYo68+aCiV0BN7OrJKQVDpI1WkpEXk5X+nXO +H0jOZvQ8QCaSmGwb7iRGDBezUqXbpZGRzzfTb+cnCDpOGR86p1hcF895P4vkp9Mm +I50mD1hp/Ed+stCNi5O/KU9DaXR2Z0vPB4zmAve14bRDtUstFJ/53CYNv6ZHdAbY +iNE6KTCEztI5gGIbqMdXSbxqVVFnFUq+NQfk1XWYN3kwFNspnWzFacxHVaIw98xc +f8LDmBxrThaA63p4ZUWiABqvDA1VZDRIuJK58bRQKfJPIx/abKwfROHdI3hRW8cW +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDfTCCAmWgAwIBAgIBADANBgkqhkiG9w0BAQUFADBgMQswCQYDVQQGEwJKUDEl +MCMGA1UEChMcU0VDT00gVHJ1c3QgU3lzdGVtcyBDTy4sTFRELjEqMCgGA1UECxMh +U2VjdXJpdHkgQ29tbXVuaWNhdGlvbiBFViBSb290Q0ExMB4XDTA3MDYwNjAyMTIz +MloXDTM3MDYwNjAyMTIzMlowYDELMAkGA1UEBhMCSlAxJTAjBgNVBAoTHFNFQ09N +IFRydXN0IFN5c3RlbXMgQ08uLExURC4xKjAoBgNVBAsTIVNlY3VyaXR5IENvbW11 +bmljYXRpb24gRVYgUm9vdENBMTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC +ggEBALx/7FebJOD+nLpCeamIivqA4PUHKUPqjgo0No0c+qe1OXj/l3X3L+SqawSE +RMqm4miO/VVQYg+kcQ7OBzgtQoVQrTyWb4vVog7P3kmJPdZkLjjlHmy1V4qe70gO +zXppFodEtZDkBp2uoQSXWHnvIEqCa4wiv+wfD+mEce3xDuS4GBPMVjZd0ZoeUWs5 +bmB2iDQL87PRsJ3KYeJkHcFGB7hj3R4zZbOOCVVSPbW9/wfrrWFVGCypaZhKqkDF +MxRldAD5kd6vA0jFQFTcD4SQaCDFkpbcLuUCRarAX1T4bepJz11sS6/vmsJWXMY1 +VkJqMF/Cq/biPT+zyRGPMUzXn0kCAwEAAaNCMEAwHQYDVR0OBBYEFDVK9U2vP9eC +OKyrcWUXdYydVZPmMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MA0G +CSqGSIb3DQEBBQUAA4IBAQCoh+ns+EBnXcPBZsdAS5f8hxOQWsTvoMpfi7ent/HW +tWS3irO4G8za+6xmiEHO6Pzk2x6Ipu0nUBsCMCRGef4Eh3CXQHPRwMFXGZpppSeZ +q51ihPZRwSzJIxXYKLerJRO1RuGGAv8mjMSIkh1W/hln8lXkgKNrnKt34VFxDSDb +EJrbvXZ5B3eZKK2aXtqxT0QsNY6llsf9g/BYxnnWmHyojf6GPgcWkuF75x3sM3Z+ +Qi5KhfmRiWiEA4Glm5q+4zfFVKtWOxgtQaQM+ELbmaDgcm+7XeEWT1MKZPlO9L9O +VL14bIjqv5wTJMJwaaJ/D8g8rQjJsJhAoyrniIPtd490 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDdzCCAl+gAwIBAgIBADANBgkqhkiG9w0BAQsFADBdMQswCQYDVQQGEwJKUDEl +MCMGA1UEChMcU0VDT00gVHJ1c3QgU3lzdGVtcyBDTy4sTFRELjEnMCUGA1UECxMe +U2VjdXJpdHkgQ29tbXVuaWNhdGlvbiBSb290Q0EyMB4XDTA5MDUyOTA1MDAzOVoX +DTI5MDUyOTA1MDAzOVowXTELMAkGA1UEBhMCSlAxJTAjBgNVBAoTHFNFQ09NIFRy +dXN0IFN5c3RlbXMgQ08uLExURC4xJzAlBgNVBAsTHlNlY3VyaXR5IENvbW11bmlj +YXRpb24gUm9vdENBMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANAV +OVKxUrO6xVmCxF1SrjpDZYBLx/KWvNs2l9amZIyoXvDjChz335c9S672XewhtUGr +zbl+dp+++T42NKA7wfYxEUV0kz1XgMX5iZnK5atq1LXaQZAQwdbWQonCv/Q4EpVM +VAX3NuRFg3sUZdbcDE3R3n4MqzvEFb46VqZab3ZpUql6ucjrappdUtAtCms1FgkQ +hNBqyjoGADdH5H5XTz+L62e4iKrFvlNVspHEfbmwhRkGeC7bYRr6hfVKkaHnFtWO +ojnflLhwHyg/i/xAXmODPIMqGplrz95Zajv8bxbXH/1KEOtOghY6rCcMU/Gt1SSw +awNQwS08Ft1ENCcadfsCAwEAAaNCMEAwHQYDVR0OBBYEFAqFqXdlBZh8QIH4D5cs +OPEK7DzPMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3 +DQEBCwUAA4IBAQBMOqNErLlFsceTfsgLCkLfZOoc7llsCLqJX2rKSpWeeo8HxdpF +coJxDjrSzG+ntKEju/Ykn8sX/oymzsLS28yN/HH8AynBbF0zX2S2ZTuJbxh2ePXc +okgfGT+Ok+vx+hfuzU7jBBJV1uXk3fs+BXziHV7Gp7yXT2g69ekuCkO2r1dcYmh8 +t/2jioSgrGK+KwmHNPBqAbubKVY8/gA3zyNs8U6qtnRGEmyR7jTV7JqR50S+kDFy +1UkC9gLl9B/rfNmWVan/7Ir5mUf/NVoCqgTLiluHcSmRvaS0eg29mvVXIwAHIRc/ +SjnRBUkLp7Y3gaVdjKozXoEofKd9J+sAro03 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDWjCCAkKgAwIBAgIBADANBgkqhkiG9w0BAQUFADBQMQswCQYDVQQGEwJKUDEY +MBYGA1UEChMPU0VDT00gVHJ1c3QubmV0MScwJQYDVQQLEx5TZWN1cml0eSBDb21t +dW5pY2F0aW9uIFJvb3RDQTEwHhcNMDMwOTMwMDQyMDQ5WhcNMjMwOTMwMDQyMDQ5 +WjBQMQswCQYDVQQGEwJKUDEYMBYGA1UEChMPU0VDT00gVHJ1c3QubmV0MScwJQYD +VQQLEx5TZWN1cml0eSBDb21tdW5pY2F0aW9uIFJvb3RDQTEwggEiMA0GCSqGSIb3 +DQEBAQUAA4IBDwAwggEKAoIBAQCzs/5/022x7xZ8V6UMbXaKL0u/ZPtM7orw8yl8 +9f/uKuDp6bpbZCKamm8sOiZpUQWZJtzVHGpxxpp9Hp3dfGzGjGdnSj74cbAZJ6kJ +DKaVv0uMDPpVmDvY6CKhS3E4eayXkmmziX7qIWgGmBSWh9JhNrxtJ1aeV+7AwFb9 +Ms+k2Y7CI9eNqPPYJayX5HA49LY6tJ07lyZDo6G8SVlyTCMwhwFY9k6+HGhWZq/N +QV3Is00qVUarH9oe4kA92819uZKAnDfdDJZkndwi92SL32HeFZRSFaB9UslLqCHJ +xrHty8OVYNEP8Ktw+N/LTX7s1vqr2b1/VPKl6Xn62dZ2JChzAgMBAAGjPzA9MB0G +A1UdDgQWBBSgc0mZaNyFW2XjmygvV5+9M7wHSDALBgNVHQ8EBAMCAQYwDwYDVR0T +AQH/BAUwAwEB/zANBgkqhkiG9w0BAQUFAAOCAQEAaECpqLvkT115swW1F7NgE+vG +kl3g0dNq/vu+m22/xwVtWSDEHPC32oRYAmP6SBbvT6UL90qY8j+eG61Ha2POCEfr +Uj94nK9NrvjVT8+amCoQQTlSxN3Zmw7vkwGusi7KaEIkQmywszo+zenaSMQVy+n5 +Bw+SUEmK3TGXX8npN6o7WWWXlDLJs58+OmJYxUmtYg5xpTKqL8aJdkNAExNnPaJU +JRDL8Try2frbSVa7pv6nQTXD4IhhyYjH3zYQIphZ6rBK+1YWc26sTfcioU+tHXot +RSflMMFe8toTyyVCUZVHA4xsIcx0Qu1T/zOLjw9XARYvz6buyXAiFL39vmwLAw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDIDCCAgigAwIBAgIBHTANBgkqhkiG9w0BAQUFADA5MQswCQYDVQQGEwJGSTEP +MA0GA1UEChMGU29uZXJhMRkwFwYDVQQDExBTb25lcmEgQ2xhc3MyIENBMB4XDTAx +MDQwNjA3Mjk0MFoXDTIxMDQwNjA3Mjk0MFowOTELMAkGA1UEBhMCRkkxDzANBgNV +BAoTBlNvbmVyYTEZMBcGA1UEAxMQU29uZXJhIENsYXNzMiBDQTCCASIwDQYJKoZI +hvcNAQEBBQADggEPADCCAQoCggEBAJAXSjWdyvANlsdE+hY3/Ei9vX+ALTU74W+o +Z6m/AxxNjG8yR9VBaKQTBME1DJqEQ/xcHf+Js+gXGM2RX/uJ4+q/Tl18GybTdXnt +5oTjV+WtKcT0OijnpXuENmmz/V52vaMtmdOQTiMofRhj8VQ7Jp12W5dCsv+u8E7s +3TmVToMGf+dJQMjFAbJUWmYdPfz56TwKnoG4cPABi+QjVHzIrviQHgCWctRUz2Ej +vOr7nQKV0ba5cTppCD8PtOFCx4j1P5iop7oc4HFx71hXgVB6XGt0Rg6DA5jDjqhu +8nYybieDwnPz3BjotJPqdURrBGAgcVeHnfO+oJAjPYok4doh28MCAwEAAaMzMDEw +DwYDVR0TAQH/BAUwAwEB/zARBgNVHQ4ECgQISqCqWITTXjwwCwYDVR0PBAQDAgEG +MA0GCSqGSIb3DQEBBQUAA4IBAQBazof5FnIVV0sd2ZvnoiYw7JNn39Yt0jSv9zil +zqsWuasvfDXLrNAPtEwr/IDva4yRXzZ299uzGxnq9LIR/WFxRL8oszodv7ND6J+/ +3DEIcbCdjdY0RzKQxmUk96BKfARzjzlvF4xytb1LyHr4e4PDKE6cCepnP7JnBBvD +FNr450kkkdAdavphOe9r5yF1BgfYErQhIHBCcYHaPJo2vqZbDWpsmh+Re/n570K6 +Tk6ezAyNlNzZRZxe7EJQY670XcSxEtzKO6gunRRaBXW37Ndj4ro1tgQIkejanZz2 +ZrUYrAqmVCY0M9IbwdR/GjqOC6oybtv8TyWf2TLHllpwrN9M +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFcDCCA1igAwIBAgIEAJiWjTANBgkqhkiG9w0BAQsFADBYMQswCQYDVQQGEwJO +TDEeMBwGA1UECgwVU3RhYXQgZGVyIE5lZGVybGFuZGVuMSkwJwYDVQQDDCBTdGFh +dCBkZXIgTmVkZXJsYW5kZW4gRVYgUm9vdCBDQTAeFw0xMDEyMDgxMTE5MjlaFw0y +MjEyMDgxMTEwMjhaMFgxCzAJBgNVBAYTAk5MMR4wHAYDVQQKDBVTdGFhdCBkZXIg +TmVkZXJsYW5kZW4xKTAnBgNVBAMMIFN0YWF0IGRlciBOZWRlcmxhbmRlbiBFViBS +b290IENBMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA48d+ifkkSzrS +M4M1LGns3Amk41GoJSt5uAg94JG6hIXGhaTK5skuU6TJJB79VWZxXSzFYGgEt9nC +UiY4iKTWO0Cmws0/zZiTs1QUWJZV1VD+hq2kY39ch/aO5ieSZxeSAgMs3NZmdO3d +Z//BYY1jTw+bbRcwJu+r0h8QoPnFfxZpgQNH7R5ojXKhTbImxrpsX23Wr9GxE46p +rfNeaXUmGD5BKyF/7otdBwadQ8QpCiv8Kj6GyzyDOvnJDdrFmeK8eEEzduG/L13l +pJhQDBXd4Pqcfzho0LKmeqfRMb1+ilgnQ7O6M5HTp5gVXJrm0w912fxBmJc+qiXb +j5IusHsMX/FjqTf5m3VpTCgmJdrV8hJwRVXj33NeN/UhbJCONVrJ0yPr08C+eKxC +KFhmpUZtcALXEPlLVPxdhkqHz3/KRawRWrUgUY0viEeXOcDPusBCAUCZSCELa6fS +/ZbV0b5GnUngC6agIk440ME8MLxwjyx1zNDFjFE7PZQIZCZhfbnDZY8UnCHQqv0X +cgOPvZuM5l5Tnrmd74K74bzickFbIZTTRTeU0d8JOV3nI6qaHcptqAqGhYqCvkIH +1vI4gnPah1vlPNOePqc7nvQDs/nxfRN0Av+7oeX6AHkcpmZBiFxgV6YuCcS6/ZrP +px9Aw7vMWgpVSzs4dlG4Y4uElBbmVvMCAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB +/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFP6rAJCYniT8qcwaivsnuL8wbqg7 +MA0GCSqGSIb3DQEBCwUAA4ICAQDPdyxuVr5Os7aEAJSrR8kN0nbHhp8dB9O2tLsI +eK9p0gtJ3jPFrK3CiAJ9Brc1AsFgyb/E6JTe1NOpEyVa/m6irn0F3H3zbPB+po3u +2dfOWBfoqSmuc0iH55vKbimhZF8ZE/euBhD/UcabTVUlT5OZEAFTdfETzsemQUHS +v4ilf0X8rLiltTMMgsT7B/Zq5SWEXwbKwYY5EdtYzXc7LMJMD16a4/CrPmEbUCTC +wPTxGfARKbalGAKb12NMcIxHowNDXLldRqANb/9Zjr7dn3LDWyvfjFvO5QxGbJKy +CqNMVEIYFRIYvdr8unRu/8G2oGTYqV9Vrp9canaW2HNnh/tNf1zuacpzEPuKqf2e +vTY4SUmH9A4U8OmHuD+nT3pajnnUk+S7aFKErGzp85hwVXIy+TSrK0m1zSBi5Dp6 +Z2Orltxtrpfs/J92VoguZs9btsmksNcFuuEnL5O7Jiqik7Ab846+HUCjuTaPPoIa +Gl6I6lD4WeKDRikL40Rc4ZW2aZCaFG+XroHPaO+Zmr615+F/+PoTRxZMzG0IQOeL +eG9QgkRQP2YGiqtDhFZKDyAthg710tvSeopLzaXoTvFeJiUBWSOgftL2fiFX1ye8 +FVdMpEbB4IMeDExNH08GGeL5qPQ6gqGyeUN51q1veieQA6TqJIc/2b3Z6fJfUEkc +7uzXLg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDujCCAqKgAwIBAgIEAJiWijANBgkqhkiG9w0BAQUFADBVMQswCQYDVQQGEwJO +TDEeMBwGA1UEChMVU3RhYXQgZGVyIE5lZGVybGFuZGVuMSYwJAYDVQQDEx1TdGFh +dCBkZXIgTmVkZXJsYW5kZW4gUm9vdCBDQTAeFw0wMjEyMTcwOTIzNDlaFw0xNTEy +MTYwOTE1MzhaMFUxCzAJBgNVBAYTAk5MMR4wHAYDVQQKExVTdGFhdCBkZXIgTmVk +ZXJsYW5kZW4xJjAkBgNVBAMTHVN0YWF0IGRlciBOZWRlcmxhbmRlbiBSb290IENB +MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAmNK1URF6gaYUmHFtvszn +ExvWJw56s2oYHLZhWtVhCb/ekBPHZ+7d89rFDBKeNVU+LCeIQGv33N0iYfXCxw71 +9tV2U02PjLwYdjeFnejKScfST5gTCaI+Ioicf9byEGW07l8Y1Rfj+MX94p2i71MO +hXeiD+EwR+4A5zN9RGcaC1Hoi6CeUJhoNFIfLm0B8mBF8jHrqTFoKbt6QZ7GGX+U +tFE5A3+y3qcym7RHjm+0Sq7lr7HcsBthvJly3uSJt3omXdozSVtSnA71iq3DuD3o +BmrC1SoLbHuEvVYFy4ZlkuxEK7COudxwC0barbxjiDn622r+I/q85Ej0ZytqERAh +SQIDAQABo4GRMIGOMAwGA1UdEwQFMAMBAf8wTwYDVR0gBEgwRjBEBgRVHSAAMDww +OgYIKwYBBQUHAgEWLmh0dHA6Ly93d3cucGtpb3ZlcmhlaWQubmwvcG9saWNpZXMv +cm9vdC1wb2xpY3kwDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBSofeu8Y6R0E3QA +7Jbg0zTBLL9s+DANBgkqhkiG9w0BAQUFAAOCAQEABYSHVXQ2YcG70dTGFagTtJ+k +/rvuFbQvBgwp8qiSpGEN/KtcCFtREytNwiphyPgJWPwtArI5fZlmgb9uXJVFIGzm +eafR2Bwp/MIgJ1HI8XxdNGdphREwxgDS1/PTfLbwMVcoEoJz6TMvplW0C5GUR5z6 +u3pCMuiufi3IvKwUv9kP2Vv8wfl6leF9fpb8cbDCTMjfRTTJzg3ynGQI0DvDKcWy +7ZAEwbEpkcUwb8GpcjPM/l0WFywRaed+/sWDCN+83CI6LiBpIzlWYGeQiy52OfsR +iJf2fL1LuCAWZwWN4jvBcj+UlTfHXbme2JOhF4//DGYVwSR8MnwDHTuhWEUykw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFyjCCA7KgAwIBAgIEAJiWjDANBgkqhkiG9w0BAQsFADBaMQswCQYDVQQGEwJO +TDEeMBwGA1UECgwVU3RhYXQgZGVyIE5lZGVybGFuZGVuMSswKQYDVQQDDCJTdGFh +dCBkZXIgTmVkZXJsYW5kZW4gUm9vdCBDQSAtIEcyMB4XDTA4MDMyNjExMTgxN1oX +DTIwMDMyNTExMDMxMFowWjELMAkGA1UEBhMCTkwxHjAcBgNVBAoMFVN0YWF0IGRl +ciBOZWRlcmxhbmRlbjErMCkGA1UEAwwiU3RhYXQgZGVyIE5lZGVybGFuZGVuIFJv +b3QgQ0EgLSBHMjCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMVZ5291 +qj5LnLW4rJ4L5PnZyqtdj7U5EILXr1HgO+EASGrP2uEGQxGZqhQlEq0i6ABtQ8Sp +uOUfiUtnvWFI7/3S4GCI5bkYYCjDdyutsDeqN95kWSpGV+RLufg3fNU254DBtvPU +Z5uW6M7XxgpT0GtJlvOjCwV3SPcl5XCsMBQgJeN/dVrlSPhOewMHBPqCYYdu8DvE +pMfQ9XQ+pV0aCPKbJdL2rAQmPlU6Yiile7Iwr/g3wtG61jj99O9JMDeZJiFIhQGp +5Rbn3JBV3w/oOM2ZNyFPXfUib2rFEhZgF1XyZWampzCROME4HYYEhLoaJXhena/M +UGDWE4dS7WMfbWV9whUYdMrhfmQpjHLYFhN9C0lK8SgbIHRrxT3dsKpICT0ugpTN +GmXZK4iambwYfp/ufWZ8Pr2UuIHOzZgweMFvZ9C+X+Bo7d7iscksWXiSqt8rYGPy +5V6548r6f1CGPqI0GAwJaCgRHOThuVw+R7oyPxjMW4T182t0xHJ04eOLoEq9jWYv +6q012iDTiIJh8BIitrzQ1aTsr1SIJSQ8p22xcik/Plemf1WvbibG/ufMQFxRRIEK +eN5KzlW/HdXZt1bv8Hb/C3m1r737qWmRRpdogBQ2HbN/uymYNqUg+oJgYjOk7Na6 +B6duxc8UpufWkjTYgfX8HV2qXB72o007uPc5AgMBAAGjgZcwgZQwDwYDVR0TAQH/ +BAUwAwEB/zBSBgNVHSAESzBJMEcGBFUdIAAwPzA9BggrBgEFBQcCARYxaHR0cDov +L3d3dy5wa2lvdmVyaGVpZC5ubC9wb2xpY2llcy9yb290LXBvbGljeS1HMjAOBgNV +HQ8BAf8EBAMCAQYwHQYDVR0OBBYEFJFoMocVHYnitfGsNig0jQt8YojrMA0GCSqG +SIb3DQEBCwUAA4ICAQCoQUpnKpKBglBu4dfYszk78wIVCVBR7y29JHuIhjv5tLyS +CZa59sCrI2AGeYwRTlHSeYAz+51IvuxBQ4EffkdAHOV6CMqqi3WtFMTC6GY8ggen +5ieCWxjmD27ZUD6KQhgpxrRW/FYQoAUXvQwjf/ST7ZwaUb7dRUG/kSS0H4zpX897 +IZmflZ85OkYcbPnNe5yQzSipx6lVu6xiNGI1E0sUOlWDuYaNkqbG9AclVMwWVxJK +gnjIFNkXgiYtXSAfea7+1HAWFpWD2DU5/1JddRwWxRNVz0fMdWVSSt7wsKfkCpYL ++63C4iWEst3kvX5ZbJvw8NjnyvLplzh+ib7M+zkXYT9y2zqR2GUBGR2tUKRXCnxL +vJxxcypFURmFzI79R6d0lR2o0a9OF7FpJsKqeFdbxU2n5Z4FF5TKsl+gSRiNNOkm +bEgeqmiSBeGCc1qb3AdbCG19ndeNIdn8FCCqwkXfP+cAslHkwvgFuXkajDTznlvk +N1trSt8sV4pAWja63XVECDdCcAz+3F4hoKOKwJCcaNpQ5kUQR3i2TtJlycM33+FC +Y7BXN0Ute4qcvwXqZVUz9zkQxSgqIXobisQk+T8VyJoVIPVVYpbtbZNQvOSqeK3Z +ywplh6ZmwcSBo3c6WB4L7oOLnR7SUqTMHW+wmG2UMbX4cQrcufx9MmDm66+KAQ== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFdDCCA1ygAwIBAgIEAJiiOTANBgkqhkiG9w0BAQsFADBaMQswCQYDVQQGEwJO +TDEeMBwGA1UECgwVU3RhYXQgZGVyIE5lZGVybGFuZGVuMSswKQYDVQQDDCJTdGFh +dCBkZXIgTmVkZXJsYW5kZW4gUm9vdCBDQSAtIEczMB4XDTEzMTExNDExMjg0MloX +DTI4MTExMzIzMDAwMFowWjELMAkGA1UEBhMCTkwxHjAcBgNVBAoMFVN0YWF0IGRl +ciBOZWRlcmxhbmRlbjErMCkGA1UEAwwiU3RhYXQgZGVyIE5lZGVybGFuZGVuIFJv +b3QgQ0EgLSBHMzCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAL4yolQP +cPssXFnrbMSkUeiFKrPMSjTysF/zDsccPVMeiAho2G89rcKezIJnByeHaHE6n3WW +IkYFsO2tx1ueKt6c/DrGlaf1F2cY5y9JCAxcz+bMNO14+1Cx3Gsy8KL+tjzk7FqX +xz8ecAgwoNzFs21v0IJyEavSgWhZghe3eJJg+szeP4TrjTgzkApyI/o1zCZxMdFy +KJLZWyNtZrVtB0LrpjPOktvA9mxjeM3KTj215VKb8b475lRgsGYeCasH/lSJEULR +9yS6YHgamPfJEf0WwTUaVHXvQ9Plrk7O53vDxk5hUUurmkVLoR9BvUhTFXFkC4az +5S6+zqQbwSmEorXLCCN2QyIkHxcE1G6cxvx/K2Ya7Irl1s9N9WMJtxU51nus6+N8 +6U78dULI7ViVDAZCopz35HCz33JvWjdAidiFpNfxC95DGdRKWCyMijmev4SH8RY7 +Ngzp07TKbBlBUgmhHbBqv4LvcFEhMtwFdozL92TkA1CvjJFnq8Xy7ljY3r735zHP +bMk7ccHViLVlvMDoFxcHErVc0qsgk7TmgoNwNsXNo42ti+yjwUOH5kPiNL6VizXt +BznaqB16nzaeErAMZRKQFWDZJkBE41ZgpRDUajz9QdwOWke275dhdU/Z/seyHdTt +XUmzqWrLZoQT1Vyg3N9udwbRcXXIV2+vD3dbAgMBAAGjQjBAMA8GA1UdEwEB/wQF +MAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBRUrfrHkleuyjWcLhL75Lpd +INyUVzANBgkqhkiG9w0BAQsFAAOCAgEAMJmdBTLIXg47mAE6iqTnB/d6+Oea31BD +U5cqPco8R5gu4RV78ZLzYdqQJRZlwJ9UXQ4DO1t3ApyEtg2YXzTdO2PCwyiBwpwp +LiniyMMB8jPqKqrMCQj3ZWfGzd/TtiunvczRDnBfuCPRy5FOCvTIeuXZYzbB1N/8 +Ipf3YF3qKS9Ysr1YvY2WTxB1v0h7PVGHoTx0IsL8B3+A3MSs/mrBcDCw6Y5p4ixp +gZQJut3+TcCDjJRYwEYgr5wfAvg1VUkvRtTA8KCWAg8zxXHzniN9lLf9OtMJgwYh +/WA9rjLA0u6NpvDntIJ8CsxwyXmA+P5M9zWEGYox+wrZ13+b8KKaa8MFSu1BYBQw +0aoRQm7TIwIEC8Zl3d1Sd9qBa7Ko+gE4uZbqKmxnl4mUnrzhVNXkanjvSr0rmj1A +fsbAddJu+2gw7OyLnflJNZoaLNmzlTnVHpL3prllL+U9bTpITAjc5CgSKL59NVzq +4BZ+Extq1z7XnvwtdbLBFNUjA9tbbws+eC8N3jONFrdI54OagQ97wUNNVQQXOEpR +1VmiiXTTn74eS9fGbbeIJG9gkaSChVtWQbzQRKtqE77RLFi3EjNYsjdj3BP1lB0/ +QFH1T/U67cjF68IeHRaVesd+QnGTbksVtzDfqu1XhUisHWrdOWnk4Xl4vs4Fv6EM +94B7IWcnMFk= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEDzCCAvegAwIBAgIBADANBgkqhkiG9w0BAQUFADBoMQswCQYDVQQGEwJVUzEl +MCMGA1UEChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEyMDAGA1UECxMp +U3RhcmZpZWxkIENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQw +NjI5MTczOTE2WhcNMzQwNjI5MTczOTE2WjBoMQswCQYDVQQGEwJVUzElMCMGA1UE +ChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEyMDAGA1UECxMpU3RhcmZp +ZWxkIENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwggEgMA0GCSqGSIb3 +DQEBAQUAA4IBDQAwggEIAoIBAQC3Msj+6XGmBIWtDBFk385N78gDGIc/oav7PKaf +8MOh2tTYbitTkPskpD6E8J7oX+zlJ0T1KKY/e97gKvDIr1MvnsoFAZMej2YcOadN ++lq2cwQlZut3f+dZxkqZJRRU6ybH838Z1TBwj6+wRir/resp7defqgSHo9T5iaU0 +X9tDkYI22WY8sbi5gv2cOj4QyDvvBmVmepsZGD3/cVE8MC5fvj13c7JdBmzDI1aa +K4UmkhynArPkPw2vCHmCuDY96pzTNbO8acr1zJ3o/WSNF4Azbl5KXZnJHoe0nRrA +1W4TNSNe35tfPe/W93bC6j67eA0cQmdrBNj41tpvi/JEoAGrAgEDo4HFMIHCMB0G +A1UdDgQWBBS/X7fRzt0fhvRbVazc1xDCDqmI5zCBkgYDVR0jBIGKMIGHgBS/X7fR +zt0fhvRbVazc1xDCDqmI56FspGowaDELMAkGA1UEBhMCVVMxJTAjBgNVBAoTHFN0 +YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAsTKVN0YXJmaWVsZCBD +bGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5ggEAMAwGA1UdEwQFMAMBAf8w +DQYJKoZIhvcNAQEFBQADggEBAAWdP4id0ckaVaGsafPzWdqbAYcaT1epoXkJKtv3 +L7IezMdeatiDh6GX70k1PncGQVhiv45YuApnP+yz3SFmH8lU+nLMPUxA2IGvd56D +eruix/U0F47ZEUD0/CwqTRV/p2JdLiXTAAsgGh1o+Re49L2L7ShZ3U0WixeDyLJl +xy16paq8U4Zt3VekyvggQQto8PT7dL5WXXp59fkdheMtlb71cZBDzI0fmgAKhynp +VSJYACPq4xJDKVtHCN2MQWplBqjlIapBtJUhlbl90TSrE9atvNziPTnNvT51cKEY +WQPJIrSPnNVeKtelttQKbfi3QBFGmh95DmK/D5fs4C8fF5Q= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIID3TCCAsWgAwIBAgIBADANBgkqhkiG9w0BAQsFADCBjzELMAkGA1UEBhMCVVMx +EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxJTAjBgNVBAoT +HFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAMTKVN0YXJmaWVs +ZCBSb290IENlcnRpZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5MDkwMTAwMDAw +MFoXDTM3MTIzMTIzNTk1OVowgY8xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdBcml6 +b25hMRMwEQYDVQQHEwpTY290dHNkYWxlMSUwIwYDVQQKExxTdGFyZmllbGQgVGVj +aG5vbG9naWVzLCBJbmMuMTIwMAYDVQQDEylTdGFyZmllbGQgUm9vdCBDZXJ0aWZp +Y2F0ZSBBdXRob3JpdHkgLSBHMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC +ggEBAL3twQP89o/8ArFvW59I2Z154qK3A2FWGMNHttfKPTUuiUP3oWmb3ooa/RMg +nLRJdzIpVv257IzdIvpy3Cdhl+72WoTsbhm5iSzchFvVdPtrX8WJpRBSiUZV9Lh1 +HOZ/5FSuS/hVclcCGfgXcVnrHigHdMWdSL5stPSksPNkN3mSwOxGXn/hbVNMYq/N +Hwtjuzqd+/x5AJhhdM8mgkBj87JyahkNmcrUDnXMN/uLicFZ8WJ/X7NfZTD4p7dN +dloedl40wOiWVpmKs/B/pM293DIxfJHP4F8R+GuqSVzRmZTRouNjWwl2tVZi4Ut0 +HZbUJtQIBFnQmA4O5t78w+wfkPECAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFHwMMh+n2TB/xH1oo2Kooc6rB1snMA0G +CSqGSIb3DQEBCwUAA4IBAQARWfolTwNvlJk7mh+ChTnUdgWUXuEok21iXQnCoKjU +sHU48TRqneSfioYmUeYs0cYtbpUgSpIB7LiKZ3sx4mcujJUDJi5DnUox9g61DLu3 +4jd/IroAow57UvtruzvE03lRTs2Q9GcHGcg8RnoNAX3FWOdt5oUwF5okxBDgBPfg +8n/Uqgr/Qh037ZTlZFkSIHc40zI+OIF1lnP6aI+xy84fxez6nH7PfrHxBy22/L/K +pL/QlwVKvOoYKAKQvVR4CSFx09F9HdkWsKlhPdAKACL8x3vLCWRFCztAgfd9fDL1 +mMpYjn0q7pBZc2T5NnReJaH1ZgUufzkVqSr7UIuOhWn0 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIID7zCCAtegAwIBAgIBADANBgkqhkiG9w0BAQsFADCBmDELMAkGA1UEBhMCVVMx +EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxJTAjBgNVBAoT +HFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xOzA5BgNVBAMTMlN0YXJmaWVs +ZCBTZXJ2aWNlcyBSb290IENlcnRpZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5 +MDkwMTAwMDAwMFoXDTM3MTIzMTIzNTk1OVowgZgxCzAJBgNVBAYTAlVTMRAwDgYD +VQQIEwdBcml6b25hMRMwEQYDVQQHEwpTY290dHNkYWxlMSUwIwYDVQQKExxTdGFy +ZmllbGQgVGVjaG5vbG9naWVzLCBJbmMuMTswOQYDVQQDEzJTdGFyZmllbGQgU2Vy +dmljZXMgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgLSBHMjCCASIwDQYJKoZI +hvcNAQEBBQADggEPADCCAQoCggEBANUMOsQq+U7i9b4Zl1+OiFOxHz/Lz58gE20p +OsgPfTz3a3Y4Y9k2YKibXlwAgLIvWX/2h/klQ4bnaRtSmpDhcePYLQ1Ob/bISdm2 +8xpWriu2dBTrz/sm4xq6HZYuajtYlIlHVv8loJNwU4PahHQUw2eeBGg6345AWh1K +Ts9DkTvnVtYAcMtS7nt9rjrnvDH5RfbCYM8TWQIrgMw0R9+53pBlbQLPLJGmpufe +hRhJfGZOozptqbXuNC66DQO4M99H67FrjSXZm86B0UVGMpZwh94CDklDhbZsc7tk +6mFBrMnUVN+HL8cisibMn1lUaJ/8viovxFUcdUBgF4UCVTmLfwUCAwEAAaNCMEAw +DwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFJxfAN+q +AdcwKziIorhtSpzyEZGDMA0GCSqGSIb3DQEBCwUAA4IBAQBLNqaEd2ndOxmfZyMI +bw5hyf2E3F/YNoHN2BtBLZ9g3ccaaNnRbobhiCPPE95Dz+I0swSdHynVv/heyNXB +ve6SbzJ08pGCL72CQnqtKrcgfU28elUSwhXqvfdqlS5sdJ/PHLTyxQGjhdByPq1z +qwubdQxtRbeOlKyWN7Wg0I8VRw7j6IPdj/3vQQF3zCepYoUz8jcI73HPdwbeyBkd +iEDPfUYd/x7H4c7/I9vG+o1VTqkC50cRRj70/b17KSa7qWFiNyi2LSr2EIZkyXCn +0q23KXB56jzaYyWf/Wi3MOxw+3WKt21gZ7IeyLnp2KhvAotnDU0mV3HaIPzBSlCN +sSi6 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIHyTCCBbGgAwIBAgIBATANBgkqhkiG9w0BAQUFADB9MQswCQYDVQQGEwJJTDEW +MBQGA1UEChMNU3RhcnRDb20gTHRkLjErMCkGA1UECxMiU2VjdXJlIERpZ2l0YWwg +Q2VydGlmaWNhdGUgU2lnbmluZzEpMCcGA1UEAxMgU3RhcnRDb20gQ2VydGlmaWNh +dGlvbiBBdXRob3JpdHkwHhcNMDYwOTE3MTk0NjM2WhcNMzYwOTE3MTk0NjM2WjB9 +MQswCQYDVQQGEwJJTDEWMBQGA1UEChMNU3RhcnRDb20gTHRkLjErMCkGA1UECxMi +U2VjdXJlIERpZ2l0YWwgQ2VydGlmaWNhdGUgU2lnbmluZzEpMCcGA1UEAxMgU3Rh +cnRDb20gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwggIiMA0GCSqGSIb3DQEBAQUA +A4ICDwAwggIKAoICAQDBiNsJvGxGfHiflXu1M5DycmLWwTYgIiRezul38kMKogZk +pMyONvg45iPwbm2xPN1yo4UcodM9tDMr0y+v/uqwQVlntsQGfQqedIXWeUyAN3rf +OQVSWff0G0ZDpNKFhdLDcfN1YjS6LIp/Ho/u7TTQEceWzVI9ujPW3U3eCztKS5/C +Ji/6tRYccjV3yjxd5srhJosaNnZcAdt0FCX+7bWgiA/deMotHweXMAEtcnn6RtYT +Kqi5pquDSR3l8u/d5AGOGAqPY1MWhWKpDhk6zLVmpsJrdAfkK+F2PrRt2PZE4XNi +HzvEvqBTViVsUQn3qqvKv3b9bZvzndu/PWa8DFaqr5hIlTpL36dYUNk4dalb6kMM +Av+Z6+hsTXBbKWWc3apdzK8BMewM69KN6Oqce+Zu9ydmDBpI125C4z/eIT574Q1w ++2OqqGwaVLRcJXrJosmLFqa7LH4XXgVNWG4SHQHuEhANxjJ/GP/89PrNbpHoNkm+ +Gkhpi8KWTRoSsmkXwQqQ1vp5Iki/untp+HDH+no32NgN0nZPV/+Qt+OR0t3vwmC3 +Zzrd/qqc8NSLf3Iizsafl7b4r4qgEKjZ+xjGtrVcUjyJthkqcwEKDwOzEmDyei+B +26Nu/yYwl/WL3YlXtq09s68rxbd2AvCl1iuahhQqcvbjM4xdCUsT37uMdBNSSwID +AQABo4ICUjCCAk4wDAYDVR0TBAUwAwEB/zALBgNVHQ8EBAMCAa4wHQYDVR0OBBYE +FE4L7xqkQFulF2mHMMo0aEPQQa7yMGQGA1UdHwRdMFswLKAqoCiGJmh0dHA6Ly9j +ZXJ0LnN0YXJ0Y29tLm9yZy9zZnNjYS1jcmwuY3JsMCugKaAnhiVodHRwOi8vY3Js +LnN0YXJ0Y29tLm9yZy9zZnNjYS1jcmwuY3JsMIIBXQYDVR0gBIIBVDCCAVAwggFM +BgsrBgEEAYG1NwEBATCCATswLwYIKwYBBQUHAgEWI2h0dHA6Ly9jZXJ0LnN0YXJ0 +Y29tLm9yZy9wb2xpY3kucGRmMDUGCCsGAQUFBwIBFilodHRwOi8vY2VydC5zdGFy +dGNvbS5vcmcvaW50ZXJtZWRpYXRlLnBkZjCB0AYIKwYBBQUHAgIwgcMwJxYgU3Rh +cnQgQ29tbWVyY2lhbCAoU3RhcnRDb20pIEx0ZC4wAwIBARqBl0xpbWl0ZWQgTGlh +YmlsaXR5LCByZWFkIHRoZSBzZWN0aW9uICpMZWdhbCBMaW1pdGF0aW9ucyogb2Yg +dGhlIFN0YXJ0Q29tIENlcnRpZmljYXRpb24gQXV0aG9yaXR5IFBvbGljeSBhdmFp +bGFibGUgYXQgaHR0cDovL2NlcnQuc3RhcnRjb20ub3JnL3BvbGljeS5wZGYwEQYJ +YIZIAYb4QgEBBAQDAgAHMDgGCWCGSAGG+EIBDQQrFilTdGFydENvbSBGcmVlIFNT +TCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTANBgkqhkiG9w0BAQUFAAOCAgEAFmyZ +9GYMNPXQhV59CuzaEE44HF7fpiUFS5Eyweg78T3dRAlbB0mKKctmArexmvclmAk8 +jhvh3TaHK0u7aNM5Zj2gJsfyOZEdUauCe37Vzlrk4gNXcGmXCPleWKYK34wGmkUW +FjgKXlf2Ysd6AgXmvB618p70qSmD+LIU424oh0TDkBreOKk8rENNZEXO3SipXPJz +ewT4F+irsfMuXGRuczE6Eri8sxHkfY+BUZo7jYn0TZNmezwD7dOaHZrzZVD1oNB1 +ny+v8OqCQ5j4aZyJecRDjkZy42Q2Eq/3JR44iZB3fsNrarnDy0RLrHiQi+fHLB5L +EUTINFInzQpdn4XBidUaePKVEFMy3YCEZnXZtWgo+2EuvoSoOMCZEoalHmdkrQYu +L6lwhceWD3yJZfWOQ1QOq92lgDmUYMA0yZZwLKMS9R9Ie70cfmu3nZD0Ijuu+Pwq +yvqCUqDvr0tVk+vBtfAii6w0TiYiBKGHLHVKt+V9E9e4DGTANtLJL4YSjCMJwRuC +O3NJo2pXh5Tl1njFmUNj403gdy3hZZlyaQQaRwnmDwFWJPsfvw55qVguucQJAX6V +um0ABj6y6koQOdjQK/W/7HW/lwLFCRsI3FU34oH7N4RDYiDK51ZLZer+bMEkkySh +NOsF/5oirpt9P/FlUQqmMGqz9IgcgA38corog14= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIHhzCCBW+gAwIBAgIBLTANBgkqhkiG9w0BAQsFADB9MQswCQYDVQQGEwJJTDEW +MBQGA1UEChMNU3RhcnRDb20gTHRkLjErMCkGA1UECxMiU2VjdXJlIERpZ2l0YWwg +Q2VydGlmaWNhdGUgU2lnbmluZzEpMCcGA1UEAxMgU3RhcnRDb20gQ2VydGlmaWNh +dGlvbiBBdXRob3JpdHkwHhcNMDYwOTE3MTk0NjM3WhcNMzYwOTE3MTk0NjM2WjB9 +MQswCQYDVQQGEwJJTDEWMBQGA1UEChMNU3RhcnRDb20gTHRkLjErMCkGA1UECxMi +U2VjdXJlIERpZ2l0YWwgQ2VydGlmaWNhdGUgU2lnbmluZzEpMCcGA1UEAxMgU3Rh +cnRDb20gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwggIiMA0GCSqGSIb3DQEBAQUA +A4ICDwAwggIKAoICAQDBiNsJvGxGfHiflXu1M5DycmLWwTYgIiRezul38kMKogZk +pMyONvg45iPwbm2xPN1yo4UcodM9tDMr0y+v/uqwQVlntsQGfQqedIXWeUyAN3rf +OQVSWff0G0ZDpNKFhdLDcfN1YjS6LIp/Ho/u7TTQEceWzVI9ujPW3U3eCztKS5/C +Ji/6tRYccjV3yjxd5srhJosaNnZcAdt0FCX+7bWgiA/deMotHweXMAEtcnn6RtYT +Kqi5pquDSR3l8u/d5AGOGAqPY1MWhWKpDhk6zLVmpsJrdAfkK+F2PrRt2PZE4XNi +HzvEvqBTViVsUQn3qqvKv3b9bZvzndu/PWa8DFaqr5hIlTpL36dYUNk4dalb6kMM +Av+Z6+hsTXBbKWWc3apdzK8BMewM69KN6Oqce+Zu9ydmDBpI125C4z/eIT574Q1w ++2OqqGwaVLRcJXrJosmLFqa7LH4XXgVNWG4SHQHuEhANxjJ/GP/89PrNbpHoNkm+ +Gkhpi8KWTRoSsmkXwQqQ1vp5Iki/untp+HDH+no32NgN0nZPV/+Qt+OR0t3vwmC3 +Zzrd/qqc8NSLf3Iizsafl7b4r4qgEKjZ+xjGtrVcUjyJthkqcwEKDwOzEmDyei+B +26Nu/yYwl/WL3YlXtq09s68rxbd2AvCl1iuahhQqcvbjM4xdCUsT37uMdBNSSwID +AQABo4ICEDCCAgwwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYD +VR0OBBYEFE4L7xqkQFulF2mHMMo0aEPQQa7yMB8GA1UdIwQYMBaAFE4L7xqkQFul +F2mHMMo0aEPQQa7yMIIBWgYDVR0gBIIBUTCCAU0wggFJBgsrBgEEAYG1NwEBATCC +ATgwLgYIKwYBBQUHAgEWImh0dHA6Ly93d3cuc3RhcnRzc2wuY29tL3BvbGljeS5w +ZGYwNAYIKwYBBQUHAgEWKGh0dHA6Ly93d3cuc3RhcnRzc2wuY29tL2ludGVybWVk +aWF0ZS5wZGYwgc8GCCsGAQUFBwICMIHCMCcWIFN0YXJ0IENvbW1lcmNpYWwgKFN0 +YXJ0Q29tKSBMdGQuMAMCAQEagZZMaW1pdGVkIExpYWJpbGl0eSwgcmVhZCB0aGUg +c2VjdGlvbiAqTGVnYWwgTGltaXRhdGlvbnMqIG9mIHRoZSBTdGFydENvbSBDZXJ0 +aWZpY2F0aW9uIEF1dGhvcml0eSBQb2xpY3kgYXZhaWxhYmxlIGF0IGh0dHA6Ly93 +d3cuc3RhcnRzc2wuY29tL3BvbGljeS5wZGYwEQYJYIZIAYb4QgEBBAQDAgAHMDgG +CWCGSAGG+EIBDQQrFilTdGFydENvbSBGcmVlIFNTTCBDZXJ0aWZpY2F0aW9uIEF1 +dGhvcml0eTANBgkqhkiG9w0BAQsFAAOCAgEAjo/n3JR5fPGFf59Jb2vKXfuM/gTF +wWLRfUKKvFO3lANmMD+x5wqnUCBVJX92ehQN6wQOQOY+2IirByeDqXWmN3PH/UvS +Ta0XQMhGvjt/UfzDtgUx3M2FIk5xt/JxXrAaxrqTi3iSSoX4eA+D/i+tLPfkpLst +0OcNOrg+zvZ49q5HJMqjNTbOx8aHmNrs++myziebiMMEofYLWWivydsQD032ZGNc +pRJvkrKTlMeIFw6Ttn5ii5B/q06f/ON1FE8qMt9bDeD1e5MNq6HPh+GlBEXoPBKl +CcWw0bdT82AUuoVpaiF8H3VhFyAXe2w7QSlc4axa0c2Mm+tgHRns9+Ww2vl5GKVF +P0lDV9LdJNUso/2RjSe15esUBppMeyG7Oq0wBhjA2MFrLH9ZXF2RsXAiV+uKa0hK +1Q8p7MZAwC+ITGgBF3f0JBlPvfrhsiAhS90a2Cl9qrjeVOwhVYBsHvUwyKMQ5bLm +KhQxw4UtjJixhlpPiVktucf3HMiKf8CdBUrmQk9io20ppB+Fq9vlgcitKj1MXVuE +JnHEhV5xJMqlG2zYYdMa4FTbzrqpMrUi9nNBCV24F10OD5mQ1kfabwo6YigUZ4LZ +8dCAWZvLMdibD4x3TrVoivJs9iQOLWxwxXPR3hTQcY+203sC9uO41Alua551hDnm +fyWl8kgAwKQB2j8= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFYzCCA0ugAwIBAgIBOzANBgkqhkiG9w0BAQsFADBTMQswCQYDVQQGEwJJTDEW +MBQGA1UEChMNU3RhcnRDb20gTHRkLjEsMCoGA1UEAxMjU3RhcnRDb20gQ2VydGlm +aWNhdGlvbiBBdXRob3JpdHkgRzIwHhcNMTAwMTAxMDEwMDAxWhcNMzkxMjMxMjM1 +OTAxWjBTMQswCQYDVQQGEwJJTDEWMBQGA1UEChMNU3RhcnRDb20gTHRkLjEsMCoG +A1UEAxMjU3RhcnRDb20gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgRzIwggIiMA0G +CSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC2iTZbB7cgNr2Cu+EWIAOVeq8Oo1XJ +JZlKxdBWQYeQTSFgpBSHO839sj60ZwNq7eEPS8CRhXBF4EKe3ikj1AENoBB5uNsD +vfOpL9HG4A/LnooUCri99lZi8cVytjIl2bLzvWXFDSxu1ZJvGIsAQRSCb0AgJnoo +D/Uefyf3lLE3PbfHkffiAez9lInhzG7TNtYKGXmu1zSCZf98Qru23QumNK9LYP5/ +Q0kGi4xDuFby2X8hQxfqp0iVAXV16iulQ5XqFYSdCI0mblWbq9zSOdIxHWDirMxW +RST1HFSr7obdljKF+ExP6JV2tgXdNiNnvP8V4so75qbsO+wmETRIjfaAKxojAuuK +HDp2KntWFhxyKrOq42ClAJ8Em+JvHhRYW6Vsi1g8w7pOOlz34ZYrPu8HvKTlXcxN +nw3h3Kq74W4a7I/htkxNeXJdFzULHdfBR9qWJODQcqhaX2YtENwvKhOuJv4KHBnM +0D4LnMgJLvlblnpHnOl68wVQdJVznjAJ85eCXuaPOQgeWeU1FEIT/wCc976qUM/i +UUjXuG+v+E5+M5iSFGI6dWPPe/regjupuznixL0sAA7IF6wT700ljtizkC+p2il9 +Ha90OrInwMEePnWjFqmveiJdnxMaz6eg6+OGCtP95paV1yPIN93EfKo2rJgaErHg +TuixO/XWb/Ew1wIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQE +AwIBBjAdBgNVHQ4EFgQUS8W0QGutHLOlHGVuRjaJhwUMDrYwDQYJKoZIhvcNAQEL +BQADggIBAHNXPyzVlTJ+N9uWkusZXn5T50HsEbZH77Xe7XRcxfGOSeD8bpkTzZ+K +2s06Ctg6Wgk/XzTQLwPSZh0avZyQN8gMjgdalEVGKua+etqhqaRpEpKwfTbURIfX +UfEpY9Z1zRbkJ4kd+MIySP3bmdCPX1R0zKxnNBFi2QwKN4fRoxdIjtIXHfbX/dtl +6/2o1PXWT6RbdejF0mCy2wl+JYt7ulKSnj7oxXehPOBKc2thz4bcQ///If4jXSRK +9dNtD2IEBVeC2m6kMyV5Sy5UGYvMLD0w6dEG/+gyRr61M3Z3qAFdlsHB1b6uJcDJ +HgoJIIihDsnzb02CVAAgp9KP5DlUFy6NHrgbuxu9mk47EDTcnIhT76IxW1hPkWLI +wpqazRVdOKnWvvgTtZ8SafJQYqz7Fzf07rh1Z2AQ+4NQ+US1dZxAF7L+/XldblhY +XzD8AK6vM8EOTmy6p6ahfzLbOOCxchcKK5HsamMm7YnUeMx0HgX4a/6ManY5Ka5l +IxKVCCIcl85bBu4M4ru8H0ST9tg4RQUh7eStqxK2A6RCLi3ECToDZ2mEmuFZkIoo +hdVddLHRDiBYmxOlsGOm7XtH/UVVMKTumtTm4ofvmMkyghEpIrwACjFeLQ/Ajulr +so8uBtjRkcfGEvRM/TAXw8HaOFvjqermobp573PYtlNXLfbQ4ddI +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFujCCA6KgAwIBAgIJALtAHEP1Xk+wMA0GCSqGSIb3DQEBBQUAMEUxCzAJBgNV +BAYTAkNIMRUwEwYDVQQKEwxTd2lzc1NpZ24gQUcxHzAdBgNVBAMTFlN3aXNzU2ln +biBHb2xkIENBIC0gRzIwHhcNMDYxMDI1MDgzMDM1WhcNMzYxMDI1MDgzMDM1WjBF +MQswCQYDVQQGEwJDSDEVMBMGA1UEChMMU3dpc3NTaWduIEFHMR8wHQYDVQQDExZT +d2lzc1NpZ24gR29sZCBDQSAtIEcyMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIIC +CgKCAgEAr+TufoskDhJuqVAtFkQ7kpJcyrhdhJJCEyq8ZVeCQD5XJM1QiyUqt2/8 +76LQwB8CJEoTlo8jE+YoWACjR8cGp4QjK7u9lit/VcyLwVcfDmJlD909Vopz2q5+ +bbqBHH5CjCA12UNNhPqE21Is8w4ndwtrvxEvcnifLtg+5hg3Wipy+dpikJKVyh+c +6bM8K8vzARO/Ws/BtQpgvd21mWRTuKCWs2/iJneRjOBiEAKfNA+k1ZIzUd6+jbqE +emA8atufK+ze3gE/bk3lUIbLtK/tREDFylqM2tIrfKjuvqblCqoOpd8FUrdVxyJd +MmqXl2MT28nbeTZ7hTpKxVKJ+STnnXepgv9VHKVxaSvRAiTysybUa9oEVeXBCsdt +MDeQKuSeFDNeFhdVxVu1yzSJkvGdJo+hB9TGsnhQ2wwMC3wLjEHXuendjIj3o02y +MszYF9rNt85mndT9Xv+9lz4pded+p2JYryU0pUHHPbwNUMoDAw8IWh+Vc3hiv69y +FGkOpeUDDniOJihC8AcLYiAQZzlG+qkDzAQ4embvIIO1jEpWjpEA/I5cgt6IoMPi +aG59je883WX0XaxR7ySArqpWl2/5rX3aYT+YdzylkbYcjCbaZaIJbcHiVOO5ykxM +gI93e2CaHt+28kgeDrpOVG2Y4OGiGqJ3UM/EY5LsRxmd6+ZrzsECAwEAAaOBrDCB +qTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWyV7 +lqRlUX64OfPAeGZe6Drn8O4wHwYDVR0jBBgwFoAUWyV7lqRlUX64OfPAeGZe6Drn +8O4wRgYDVR0gBD8wPTA7BglghXQBWQECAQEwLjAsBggrBgEFBQcCARYgaHR0cDov +L3JlcG9zaXRvcnkuc3dpc3NzaWduLmNvbS8wDQYJKoZIhvcNAQEFBQADggIBACe6 +45R88a7A3hfm5djV9VSwg/S7zV4Fe0+fdWavPOhWfvxyeDgD2StiGwC5+OlgzczO +UYrHUDFu4Up+GC9pWbY9ZIEr44OE5iKHjn3g7gKZYbge9LgriBIWhMIxkziWMaa5 +O1M/wySTVltpkuzFwbs4AOPsF6m43Md8AYOfMke6UiI0HTJ6CVanfCU2qT1L2sCC +bwq7EsiHSycR+R4tx5M/nttfJmtS2S6K8RTGRI0Vqbe/vd6mGu6uLftIdxf+u+yv +GPUqUfA5hJeVbG4bwyvEdGB5JbAKJ9/fXtI5z0V9QkvfsywexcZdylU6oJxpmo/a +77KwPJ+HbBIrZXAVUjEaJM9vMSNQH4xPjyPDdEFjHFWoFN0+4FFQz/EbMFYOkrCC +hdiDyyJkvC24JdVUorgG6q2SpCSgwYa1ShNqR88uC1aVVMvOmttqtKay20EIhid3 +92qgQmwLOM7XdVAyksLfKzAiSNDVQTglXaTpXZ/GlHXQRf0wl0OPkKsKx4ZzYEpp +Ld6leNcG2mqeSz53OiATIgHQv2ieY2BrNU0LbbqhPcCT4H8js1WtciVORvnSFu+w +ZMEBnunKoGqYDs/YYPIvSbjkQuE4NRb0yG5P94FW6LqjviOvrv1vA+ACOzB2+htt +Qc8Bsem4yWb02ybzOqR08kkkW8mw0FfB+j564ZfJ +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFvTCCA6WgAwIBAgIITxvUL1S7L0swDQYJKoZIhvcNAQEFBQAwRzELMAkGA1UE +BhMCQ0gxFTATBgNVBAoTDFN3aXNzU2lnbiBBRzEhMB8GA1UEAxMYU3dpc3NTaWdu +IFNpbHZlciBDQSAtIEcyMB4XDTA2MTAyNTA4MzI0NloXDTM2MTAyNTA4MzI0Nlow +RzELMAkGA1UEBhMCQ0gxFTATBgNVBAoTDFN3aXNzU2lnbiBBRzEhMB8GA1UEAxMY +U3dpc3NTaWduIFNpbHZlciBDQSAtIEcyMIICIjANBgkqhkiG9w0BAQEFAAOCAg8A +MIICCgKCAgEAxPGHf9N4Mfc4yfjDmUO8x/e8N+dOcbpLj6VzHVxumK4DV644N0Mv +Fz0fyM5oEMF4rhkDKxD6LHmD9ui5aLlV8gREpzn5/ASLHvGiTSf5YXu6t+WiE7br +YT7QbNHm+/pe7R20nqA1W6GSy/BJkv6FCgU+5tkL4k+73JU3/JHpMjUi0R86TieF +nbAVlDLaYQ1HTWBCrpJH6INaUFjpiou5XaHc3ZlKHzZnu0jkg7Y360g6rw9njxcH +6ATK72oxh9TAtvmUcXtnZLi2kUpCe2UuMGoM9ZDulebyzYLs2aFK7PayS+VFheZt +eJMELpyCbTapxDFkH4aDCyr0NQp4yVXPQbBH6TCfmb5hqAaEuSh6XzjZG6k4sIN/ +c8HDO0gqgg8hm7jMqDXDhBuDsz6+pJVpATqJAHgE2cn0mRmrVn5bi4Y5FZGkECwJ +MoBgs5PAKrYYC51+jUnyEEp/+dVGLxmSo5mnJqy7jDzmDrxHB9xzUfFwZC8I+bRH +HTBsROopN4WSaGa8gzj+ezku01DwH/teYLappvonQfGbGHLy9YR0SslnxFSuSGTf +jNFusB3hB48IHpmccelM2KX3RxIfdNFRnobzwqIjQAtz20um53MGjMGg6cFZrEb6 +5i/4z3GcRm25xBWNOHkDRUjvxF3XCO6HOSKGsg0PWEP3calILv3q1h8CAwEAAaOB +rDCBqTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU +F6DNweRBtjpbO8tFnb0cwpj6hlgwHwYDVR0jBBgwFoAUF6DNweRBtjpbO8tFnb0c +wpj6hlgwRgYDVR0gBD8wPTA7BglghXQBWQEDAQEwLjAsBggrBgEFBQcCARYgaHR0 +cDovL3JlcG9zaXRvcnkuc3dpc3NzaWduLmNvbS8wDQYJKoZIhvcNAQEFBQADggIB +AHPGgeAn0i0P4JUw4ppBf1AsX19iYamGamkYDHRJ1l2E6kFSGG9YrVBWIGrGvShp +WJHckRE1qTodvBqlYJ7YH39FkWnZfrt4csEGDyrOj4VwYaygzQu4OSlWhDJOhrs9 +xCrZ1x9y7v5RoSJBsXECYxqCsGKrXlcSH9/L3XWgwF15kIwb4FDm3jH+mHtwX6WQ +2K34ArZv02DdQEsixT2tOnqfGhpHkXkzuoLcMmkDlm4fS/Bx/uNncqCxv1yL5PqZ +IseEuRuNI5c/7SXgz2W79WEE790eslpBIlqhn10s6FvJbakMDHiqYMZWjwFaDGi8 +aRl5xB9+lwW/xekkUV7U1UtT7dkjWjYDZaPBA61BMPNGG4WQr2W11bHkFlt4dR2X +em1ZqSqPe97Dh4kQmUlzeMg9vVE1dCrV8X5pGyq7O70luJpaPXJhkGaH7gzWTdQR +dAtq/gsD/KNVV4n+SsuuWxcFyPKNIzFTONItaj+CuY0IavdeQXRuwxF+B6wpYJE/ +OMpXEA29MC/HpeZBoNquBYeaoKRlbEwJDIm6uNO5wJOKMPqN5ZprFQFOZ6raYlY+ +hAhm0sQ2fac+EPyI4NSA5QC9qvNOBqN6avlicuMJT+ubDgEj8Z+7fNzcbBGXJbLy +tGMU0gYqZ4yD9c7qB9iaah7s5Aq7KkzrCWA5zspi2C5u +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIF2TCCA8GgAwIBAgIQXAuFXAvnWUHfV8w/f52oNjANBgkqhkiG9w0BAQUFADBk +MQswCQYDVQQGEwJjaDERMA8GA1UEChMIU3dpc3Njb20xJTAjBgNVBAsTHERpZ2l0 +YWwgQ2VydGlmaWNhdGUgU2VydmljZXMxGzAZBgNVBAMTElN3aXNzY29tIFJvb3Qg +Q0EgMTAeFw0wNTA4MTgxMjA2MjBaFw0yNTA4MTgyMjA2MjBaMGQxCzAJBgNVBAYT +AmNoMREwDwYDVQQKEwhTd2lzc2NvbTElMCMGA1UECxMcRGlnaXRhbCBDZXJ0aWZp +Y2F0ZSBTZXJ2aWNlczEbMBkGA1UEAxMSU3dpc3Njb20gUm9vdCBDQSAxMIICIjAN +BgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA0LmwqAzZuz8h+BvVM5OAFmUgdbI9 +m2BtRsiMMW8Xw/qabFbtPMWRV8PNq5ZJkCoZSx6jbVfd8StiKHVFXqrWW/oLJdih +FvkcxC7mlSpnzNApbjyFNDhhSbEAn9Y6cV9Nbc5fuankiX9qUvrKm/LcqfmdmUc/ +TilftKaNXXsLmREDA/7n29uj/x2lzZAeAR81sH8A25Bvxn570e56eqeqDFdvpG3F +EzuwpdntMhy0XmeLVNxzh+XTF3xmUHJd1BpYwdnP2IkCb6dJtDZd0KTeByy2dbco +kdaXvij1mB7qWybJvbCXc9qukSbraMH5ORXWZ0sKbU/Lz7DkQnGMU3nn7uHbHaBu +HYwadzVcFh4rUx80i9Fs/PJnB3r1re3WmquhsUvhzDdf/X/NTa64H5xD+SpYVUNF +vJbNcA78yeNmuk6NO4HLFWR7uZToXTNShXEuT46iBhFRyePLoW4xCGQMwtI89Tbo +19AOeCMgkckkKmUpWyL3Ic6DXqTz3kvTaI9GdVyDCW4pa8RwjPWd1yAv/0bSKzjC +L3UcPX7ape8eYIVpQtPM+GP+HkM5haa2Y0EQs3MevNP6yn0WR+Kn1dCjigoIlmJW +bjTb2QK5MHXjBNLnj8KwEUAKrNVxAmKLMb7dxiNYMUJDLXT5xp6mig/p/r+D5kNX +JLrvRjSq1xIBOO0CAwEAAaOBhjCBgzAOBgNVHQ8BAf8EBAMCAYYwHQYDVR0hBBYw +FDASBgdghXQBUwABBgdghXQBUwABMBIGA1UdEwEB/wQIMAYBAf8CAQcwHwYDVR0j +BBgwFoAUAyUv3m+CATpcLNwroWm1Z9SM0/0wHQYDVR0OBBYEFAMlL95vggE6XCzc +K6FptWfUjNP9MA0GCSqGSIb3DQEBBQUAA4ICAQA1EMvspgQNDQ/NwNurqPKIlwzf +ky9NfEBWMXrrpA9gzXrzvsMnjgM+pN0S734edAY8PzHyHHuRMSG08NBsl9Tpl7Ik +Vh5WwzW9iAUPWxAaZOHHgjD5Mq2eUCzneAXQMbFamIp1TpBcahQq4FJHgmDmHtqB +sfsUC1rxn9KVuj7QG9YVHaO+htXbD8BJZLsuUBlL0iT43R4HVtA4oJVwIHaM190e +3p9xxCPvgxNcoyQVTSlAPGrEqdi3pkSlDfTgnXceQHAm/NrZNuR55LU/vJtlvrsR +ls/bxig5OgjOR1tTWsWZ/l2p3e9M1MalrQLmjAcSHm8D0W+go/MpvRLHUKKwf4ip +mXeascClOS5cfGniLLDqN2qk4Vrh9VDlg++luyqI54zb/W1elxmofmZ1a3Hqv7HH +b6D0jqTsNFFbjCYDcKF31QESVwA12yPeDooomf2xEG9L/zgtYE4snOtnta1J7ksf +rK/7DZBaZmBwXarNeNQk7shBoJMBkpxqnvy5JMWzFYJ+vq6VK+uxwNrjAWALXmms +hFZhvnEX/h0TD/7Gh0Xp/jKgGg0TpJRVcaUWi7rKibCyx/yP2FS1k2Kdzs9Z+z0Y +zirLNRWCXf9UIltxUvu3yf5gmwBBZPCqKuy2QkPOiWaByIufOVQDJdMWNY6E0F/6 +MBr1mmz0DlP5OlvRHA== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIF2TCCA8GgAwIBAgIQHp4o6Ejy5e/DfEoeWhhntjANBgkqhkiG9w0BAQsFADBk +MQswCQYDVQQGEwJjaDERMA8GA1UEChMIU3dpc3Njb20xJTAjBgNVBAsTHERpZ2l0 +YWwgQ2VydGlmaWNhdGUgU2VydmljZXMxGzAZBgNVBAMTElN3aXNzY29tIFJvb3Qg +Q0EgMjAeFw0xMTA2MjQwODM4MTRaFw0zMTA2MjUwNzM4MTRaMGQxCzAJBgNVBAYT +AmNoMREwDwYDVQQKEwhTd2lzc2NvbTElMCMGA1UECxMcRGlnaXRhbCBDZXJ0aWZp +Y2F0ZSBTZXJ2aWNlczEbMBkGA1UEAxMSU3dpc3Njb20gUm9vdCBDQSAyMIICIjAN +BgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAlUJOhJ1R5tMJ6HJaI2nbeHCOFvEr +jw0DzpPMLgAIe6szjPTpQOYXTKueuEcUMncy3SgM3hhLX3af+Dk7/E6J2HzFZ++r +0rk0X2s682Q2zsKwzxNoysjL67XiPS4h3+os1OD5cJZM/2pYmLcX5BtS5X4HAB1f +2uY+lQS3aYg5oUFgJWFLlTloYhyxCwWJwDaCFCE/rtuh/bxvHGCGtlOUSbkrRsVP +ACu/obvLP+DHVxxX6NZp+MEkUp2IVd3Chy50I9AU/SpHWrumnf2U5NGKpV+GY3aF +y6//SSj8gO1MedK75MDvAe5QQQg1I3ArqRa0jG6F6bYRzzHdUyYb3y1aSgJA/MTA +tukxGggo5WDDH8SQjhBiYEQN7Aq+VRhxLKX0srwVYv8c474d2h5Xszx+zYIdkeNL +6yxSNLCK/RJOlrDrcH+eOfdmQrGrrFLadkBXeyq96G4DsguAhYidDMfCd7Camlf0 +uPoTXGiTOmekl9AbmbeGMktg2M7v0Ax/lZ9vh0+Hio5fCHyqW/xavqGRn1V9TrAL +acywlKinh/LTSlDcX3KwFnUey7QYYpqwpzmqm59m2I2mbJYV4+by+PGDYmy7Velh +k6M99bFXi08jsJvllGov34zflVEpYKELKeRcVVi3qPyZ7iVNTA6z00yPhOgpD/0Q +VAKFyPnlw4vP5w8CAwEAAaOBhjCBgzAOBgNVHQ8BAf8EBAMCAYYwHQYDVR0hBBYw +FDASBgdghXQBUwIBBgdghXQBUwIBMBIGA1UdEwEB/wQIMAYBAf8CAQcwHQYDVR0O +BBYEFE0mICKJS9PVpAqhb97iEoHF8TwuMB8GA1UdIwQYMBaAFE0mICKJS9PVpAqh +b97iEoHF8TwuMA0GCSqGSIb3DQEBCwUAA4ICAQAyCrKkG8t9voJXiblqf/P0wS4R +fbgZPnm3qKhyN2abGu2sEzsOv2LwnN+ee6FTSA5BesogpxcbtnjsQJHzQq0Qw1zv +/2BZf82Fo4s9SBwlAjxnffUy6S8w5X2lejjQ82YqZh6NM4OKb3xuqFp1mrjX2lhI +REeoTPpMSQpKwhI3qEAMw8jh0FcNlzKVxzqfl9NX+Ave5XLzo9v/tdhZsnPdTSpx +srpJ9csc1fV5yJmz/MFMdOO0vSk3FQQoHt5FRnDsr7p4DooqzgB53MBfGWcsa0vv +aGgLQ+OswWIJ76bdZWGgr4RVSJFSHMYlkSrQwSIjYVmvRRGFHQEkNI/Ps/8XciAT +woCqISxxOQ7Qj1zB09GOInJGTB2Wrk9xseEFKZZZ9LuedT3PDTcNYtsmjGOpI99n +Bjx8Oto0QuFmtEYE3saWmA9LSHokMnWRn6z3aOkquVVlzl1h0ydw2Df+n7mvoC5W +t6NlUe07qxS/TFED6F+KBZvuim6c779o+sjaC+NCydAXFJy3SuCvkychVSa1ZC+N +8f+mQAWFBVzKBxlcCxMoTFh/wqXvRdpg065lYZ1Tg3TCrvJcwhbtkj6EPnNgiLx2 +9CzP0H1907he0ZESEOnN3col49XtmS++dYFLJPlFRpTJKSFTnCZFqhMX5OfNeOI5 +wSsSnqaeG8XmDtkx2Q== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIF4DCCA8igAwIBAgIRAPL6ZOJ0Y9ON/RAdBB92ylgwDQYJKoZIhvcNAQELBQAw +ZzELMAkGA1UEBhMCY2gxETAPBgNVBAoTCFN3aXNzY29tMSUwIwYDVQQLExxEaWdp +dGFsIENlcnRpZmljYXRlIFNlcnZpY2VzMR4wHAYDVQQDExVTd2lzc2NvbSBSb290 +IEVWIENBIDIwHhcNMTEwNjI0MDk0NTA4WhcNMzEwNjI1MDg0NTA4WjBnMQswCQYD +VQQGEwJjaDERMA8GA1UEChMIU3dpc3Njb20xJTAjBgNVBAsTHERpZ2l0YWwgQ2Vy +dGlmaWNhdGUgU2VydmljZXMxHjAcBgNVBAMTFVN3aXNzY29tIFJvb3QgRVYgQ0Eg +MjCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMT3HS9X6lds93BdY7Bx +UglgRCgzo3pOCvrY6myLURYaVa5UJsTMRQdBTxB5f3HSek4/OE6zAMaVylvNwSqD +1ycfMQ4jFrclyxy0uYAyXhqdk/HoPGAsp15XGVhRXrwsVgu42O+LgrQ8uMIkqBPH +oCE2G3pXKSinLr9xJZDzRINpUKTk4RtiGZQJo/PDvO/0vezbE53PnUgJUmfANykR +HvvSEaeFGHR55E+FFOtSN+KxRdjMDUN/rhPSays/p8LiqG12W0OfvrSdsyaGOx9/ +5fLoZigWJdBLlzin5M8J0TbDC77aO0RYjb7xnglrPvMyxyuHxuxenPaHZa0zKcQv +idm5y8kDnftslFGXEBuGCxobP/YCfnvUxVFkKJ3106yDgYjTdLRZncHrYTNaRdHL +OdAGalNgHa/2+2m8atwBz735j9m9W8E6X47aD0upm50qKGsaCnw8qyIL5XctcfaC +NYGu+HuB5ur+rPQam3Rc6I8k9l2dRsQs0h4rIWqDJ2dVSqTjyDKXZpBy2uPUZC5f +46Fq9mDU5zXNysRojddxyNMkM3OxbPlq4SjbX8Y96L5V5jcb7STZDxmPX2MYWFCB +UWVv8p9+agTnNCRxunZLWB4ZvRVgRaoMEkABnRDixzgHcgplwLa7JSnaFp6LNYth +7eVxV4O1PHGf40+/fh6Bn0GXAgMBAAGjgYYwgYMwDgYDVR0PAQH/BAQDAgGGMB0G +A1UdIQQWMBQwEgYHYIV0AVMCAgYHYIV0AVMCAjASBgNVHRMBAf8ECDAGAQH/AgED +MB0GA1UdDgQWBBRF2aWBbj2ITY1x0kbBbkUe88SAnTAfBgNVHSMEGDAWgBRF2aWB +bj2ITY1x0kbBbkUe88SAnTANBgkqhkiG9w0BAQsFAAOCAgEAlDpzBp9SSzBc1P6x +XCX5145v9Ydkn+0UjrgEjihLj6p7jjm02Vj2e6E1CqGdivdj5eu9OYLU43otb98T +PLr+flaYC/NUn81ETm484T4VvwYmneTwkLbUwp4wLh/vx3rEUMfqe9pQy3omywC0 +Wqu1kx+AiYQElY2NfwmTv9SoqORjbdlk5LgpWgi/UOGED1V7XwgiG/W9mR4U9s70 +WBCCswo9GcG/W6uqmdjyMb3lOGbcWAXH7WMaLgqXfIeTK7KK4/HsGOV1timH59yL +Gn602MnTihdsfSlEvoqq9X46Lmgxk7lq2prg2+kupYTNHAq4Sgj5nPFhJpiTt3tm +7JFe3VE/23MPrQRYCd0EApUKPtN236YQHoA96M2kZNEzx5LH4k5E4wnJTsJdhw4S +nr8PyQUQ3nqjsTzyP6WqJ3mtMX0f/fwZacXduT98zca0wjAefm6S139hdlqP65VN +vBFuIXxZN5nQBrz5Bm0yFqXZaajh3DyAHmBR3NdUIR7KYndP+tiPsys6DXhyyWhB +WkdKwqPrGtcKqzwyVcgKEZzfdNbwQBUdyLmPtTbFr/giuMod89a2GQ+fYWVq6nTI +fI/DT11lgh/ZDYnadXL77/FHZxOzyNEZiCcmmpl5fx7kLD977vHeTYuWl8PVP3wb +I+2ksx0WckNLIOFZfsLorSa/ovc= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDwzCCAqugAwIBAgIBATANBgkqhkiG9w0BAQsFADCBgjELMAkGA1UEBhMCREUx +KzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnByaXNlIFNlcnZpY2VzIEdtYkgxHzAd +BgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50ZXIxJTAjBgNVBAMMHFQtVGVsZVNl +YyBHbG9iYWxSb290IENsYXNzIDIwHhcNMDgxMDAxMTA0MDE0WhcNMzMxMDAxMjM1 +OTU5WjCBgjELMAkGA1UEBhMCREUxKzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnBy +aXNlIFNlcnZpY2VzIEdtYkgxHzAdBgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50 +ZXIxJTAjBgNVBAMMHFQtVGVsZVNlYyBHbG9iYWxSb290IENsYXNzIDIwggEiMA0G +CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCqX9obX+hzkeXaXPSi5kfl82hVYAUd +AqSzm1nzHoqvNK38DcLZSBnuaY/JIPwhqgcZ7bBcrGXHX+0CfHt8LRvWurmAwhiC +FoT6ZrAIxlQjgeTNuUk/9k9uN0goOA/FvudocP05l03Sx5iRUKrERLMjfTlH6VJi +1hKTXrcxlkIF+3anHqP1wvzpesVsqXFP6st4vGCvx9702cu+fjOlbpSD8DT6Iavq +jnKgP6TeMFvvhk1qlVtDRKgQFRzlAVfFmPHmBiiRqiDFt1MmUUOyCxGVWOHAD3bZ +wI18gfNycJ5v/hqO2V81xrJvNHy+SE/iWjnX2J14np+GPgNeGYtEotXHAgMBAAGj +QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBS/ +WSA2AHmgoCJrjNXyYdK4LMuCSjANBgkqhkiG9w0BAQsFAAOCAQEAMQOiYQsfdOhy +NsZt+U2e+iKo4YFWz827n+qrkRk4r6p8FU3ztqONpfSO9kSpp+ghla0+AGIWiPAC +uvxhI+YzmzB6azZie60EI4RYZeLbK4rnJVM3YlNfvNoBYimipidx5joifsFvHZVw +IEoHNN/q/xWA5brXethbdXwFeilHfkCoMRN3zUA7tFFHei4R40cR3p1m0IvVVGb6 +g1XqfMIpiRvpb7PO4gWEyS8+eIVibslfwXhjdFjASBgMmTnrpMwatXlajRWc2BQN +9noHV8cigwUtPJslJj0Ys6lDfMjIq2SPDqO/nBudMNva0Bkuqjzx+zOAduTNrRlP +BSeOE6Fuwg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDwzCCAqugAwIBAgIBATANBgkqhkiG9w0BAQsFADCBgjELMAkGA1UEBhMCREUx +KzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnByaXNlIFNlcnZpY2VzIEdtYkgxHzAd +BgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50ZXIxJTAjBgNVBAMMHFQtVGVsZVNl +YyBHbG9iYWxSb290IENsYXNzIDMwHhcNMDgxMDAxMTAyOTU2WhcNMzMxMDAxMjM1 +OTU5WjCBgjELMAkGA1UEBhMCREUxKzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnBy +aXNlIFNlcnZpY2VzIEdtYkgxHzAdBgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50 +ZXIxJTAjBgNVBAMMHFQtVGVsZVNlYyBHbG9iYWxSb290IENsYXNzIDMwggEiMA0G +CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC9dZPwYiJvJK7genasfb3ZJNW4t/zN +8ELg63iIVl6bmlQdTQyK9tPPcPRStdiTBONGhnFBSivwKixVA9ZIw+A5OO3yXDw/ +RLyTPWGrTs0NvvAgJ1gORH8EGoel15YUNpDQSXuhdfsaa3Ox+M6pCSzyU9XDFES4 +hqX2iys52qMzVNn6chr3IhUciJFrf2blw2qAsCTz34ZFiP0Zf3WHHx+xGwpzJFu5 +ZeAsVMhg02YXP+HMVDNzkQI6pn97djmiH5a2OK61yJN0HZ65tOVgnS9W0eDrXltM +EnAMbEQgqxHY9Bn20pxSN+f6tsIxO0rUFJmtxxr1XV/6B7h8DR/Wgx6zAgMBAAGj +QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBS1 +A/d2O2GCahKqGFPrAyGUv/7OyjANBgkqhkiG9w0BAQsFAAOCAQEAVj3vlNW92nOy +WL6ukK2YJ5f+AbGwUgC4TeQbIXQbfsDuXmkqJa9c1h3a0nnJ85cp4IaH3gRZD/FZ +1GSFS5mvJQQeyUapl96Cshtwn5z2r3Ex3XsFpSzTucpH9sry9uetuUg/vBa3wW30 +6gmv7PO15wWeph6KU1HWk4HMdJP2udqmJQV0eVp+QD6CSyYRMG7hP0HHRwA11fXT +91Q+gT3aSWqas+8QPebrb9HIIkfLzM8BMZLZGOMivgkeGj5asuRrDFR6fUNOuIml +e9eiPZaGzPImNC1qkp2aGtAw4l1OBLBfiyB+d8E9lYLRRpo7PHi4b6HQDWSieB4p +TpPDpFQUWw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEqjCCA5KgAwIBAgIOLmoAAQACH9dSISwRXDswDQYJKoZIhvcNAQEFBQAwdjEL +MAkGA1UEBhMCREUxHDAaBgNVBAoTE1RDIFRydXN0Q2VudGVyIEdtYkgxIjAgBgNV +BAsTGVRDIFRydXN0Q2VudGVyIENsYXNzIDIgQ0ExJTAjBgNVBAMTHFRDIFRydXN0 +Q2VudGVyIENsYXNzIDIgQ0EgSUkwHhcNMDYwMTEyMTQzODQzWhcNMjUxMjMxMjI1 +OTU5WjB2MQswCQYDVQQGEwJERTEcMBoGA1UEChMTVEMgVHJ1c3RDZW50ZXIgR21i +SDEiMCAGA1UECxMZVEMgVHJ1c3RDZW50ZXIgQ2xhc3MgMiBDQTElMCMGA1UEAxMc +VEMgVHJ1c3RDZW50ZXIgQ2xhc3MgMiBDQSBJSTCCASIwDQYJKoZIhvcNAQEBBQAD +ggEPADCCAQoCggEBAKuAh5uO8MN8h9foJIIRszzdQ2Lu+MNF2ujhoF/RKrLqk2jf +tMjWQ+nEdVl//OEd+DFwIxuInie5e/060smp6RQvkL4DUsFJzfb95AhmC1eKokKg +uNV/aVyQMrKXDcpK3EY+AlWJU+MaWss2xgdW94zPEfRMuzBwBJWl9jmM/XOBCH2J +XjIeIqkiRUuwZi4wzJ9l/fzLganx4Duvo4bRierERXlQXa7pIXSSTYtZgo+U4+lK +8edJsBTj9WLL1XK9H7nSn6DNqPoByNkN39r8R52zyFTfSUrxIan+GE7uSNQZu+99 +5OKdy1u2bv/jzVrndIIFuoAlOMvkaZ6vQaoahPUCAwEAAaOCATQwggEwMA8GA1Ud +EwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBTjq1RMgKHbVkO3 +kUrL84J6E1wIqzCB7QYDVR0fBIHlMIHiMIHfoIHcoIHZhjVodHRwOi8vd3d3LnRy +dXN0Y2VudGVyLmRlL2NybC92Mi90Y19jbGFzc18yX2NhX0lJLmNybIaBn2xkYXA6 +Ly93d3cudHJ1c3RjZW50ZXIuZGUvQ049VEMlMjBUcnVzdENlbnRlciUyMENsYXNz +JTIwMiUyMENBJTIwSUksTz1UQyUyMFRydXN0Q2VudGVyJTIwR21iSCxPVT1yb290 +Y2VydHMsREM9dHJ1c3RjZW50ZXIsREM9ZGU/Y2VydGlmaWNhdGVSZXZvY2F0aW9u +TGlzdD9iYXNlPzANBgkqhkiG9w0BAQUFAAOCAQEAjNfffu4bgBCzg/XbEeprS6iS +GNn3Bzn1LL4GdXpoUxUc6krtXvwjshOg0wn/9vYua0Fxec3ibf2uWWuFHbhOIprt +ZjluS5TmVfwLG4t3wVMTZonZKNaL80VKY7f9ewthXbhtvsPcW3nS7Yblok2+XnR8 +au0WOB9/WIFaGusyiC2y8zl3gK9etmF1KdsjTYjKUCjLhdLTEKJZbtOTVAB6okaV +hgWcqRmY5TFyDADiZ9lA4CQze28suVyrZZ0srHbqNZn1l7kPJOzHdiEoZa5X6AeI +dUpWoNIFOqTmjZKILPPy4cHGYdtBxceb9w4aUUXCYWvcZCcXjFq32nQozZfkvQ== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIID3TCCAsWgAwIBAgIOHaIAAQAC7LdggHiNtgYwDQYJKoZIhvcNAQEFBQAweTEL +MAkGA1UEBhMCREUxHDAaBgNVBAoTE1RDIFRydXN0Q2VudGVyIEdtYkgxJDAiBgNV +BAsTG1RDIFRydXN0Q2VudGVyIFVuaXZlcnNhbCBDQTEmMCQGA1UEAxMdVEMgVHJ1 +c3RDZW50ZXIgVW5pdmVyc2FsIENBIEkwHhcNMDYwMzIyMTU1NDI4WhcNMjUxMjMx +MjI1OTU5WjB5MQswCQYDVQQGEwJERTEcMBoGA1UEChMTVEMgVHJ1c3RDZW50ZXIg +R21iSDEkMCIGA1UECxMbVEMgVHJ1c3RDZW50ZXIgVW5pdmVyc2FsIENBMSYwJAYD +VQQDEx1UQyBUcnVzdENlbnRlciBVbml2ZXJzYWwgQ0EgSTCCASIwDQYJKoZIhvcN +AQEBBQADggEPADCCAQoCggEBAKR3I5ZEr5D0MacQ9CaHnPM42Q9e3s9B6DGtxnSR +JJZ4Hgmgm5qVSkr1YnwCqMqs+1oEdjneX/H5s7/zA1hV0qq34wQi0fiU2iIIAI3T +fCZdzHd55yx4Oagmcw6iXSVphU9VDprvxrlE4Vc93x9UIuVvZaozhDrzznq+VZeu +jRIPFDPiUHDDSYcTvFHe15gSWu86gzOSBnWLknwSaHtwag+1m7Z3W0hZneTvWq3z +wZ7U10VOylY0Ibw+F1tvdwxIAUMpsN0/lm7mlaoMwCC2/T42J5zjXM9OgdwZu5GQ +fezmlwQek8wiSdeXhrYTCjxDI3d+8NzmzSQfO4ObNDqDNOMCAwEAAaNjMGEwHwYD +VR0jBBgwFoAUkqR1LKSevoFE63n8isWVpesQdXMwDwYDVR0TAQH/BAUwAwEB/zAO +BgNVHQ8BAf8EBAMCAYYwHQYDVR0OBBYEFJKkdSyknr6BROt5/IrFlaXrEHVzMA0G +CSqGSIb3DQEBBQUAA4IBAQAo0uCG1eb4e/CX3CJrO5UUVg8RMKWaTzqwOuAGy2X1 +7caXJ/4l8lfmXpWMPmRgFVp/Lw0BxbFg/UU1z/CyvwbZ71q+s2IhtNerNXxTPqYn +8aEt2hojnczd7Dwtnic0XQ/CNnm8yUpiLe1r2X1BQ3y2qsrtYbE3ghUJGooWMNjs +ydZHcnhLEEYUjl8Or+zHL6sQ17bxbuyGssLoDZJz3KL0Dzq/YSMQiZxIQG5wALPT +ujdEWBF6AmqI8Dc08BnprNRlc/ZpjGSUOnmFKbAWKwyCPwacx/0QK54PLLae4xW/ +2TYcuiUaUj0a7CIMHOCkoj3w6DnPgcB77V0fb8XQC9eY +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIID+zCCAuOgAwIBAgIBATANBgkqhkiG9w0BAQUFADCBtzE/MD0GA1UEAww2VMOc +UktUUlVTVCBFbGVrdHJvbmlrIFNlcnRpZmlrYSBIaXptZXQgU2HEn2xhecSxY8Sx +c8SxMQswCQYDVQQGDAJUUjEPMA0GA1UEBwwGQU5LQVJBMVYwVAYDVQQKDE0oYykg +MjAwNSBUw5xSS1RSVVNUIEJpbGdpIMSwbGV0acWfaW0gdmUgQmlsacWfaW0gR8O8 +dmVubGnEn2kgSGl6bWV0bGVyaSBBLsWeLjAeFw0wNTA1MTMxMDI3MTdaFw0xNTAz +MjIxMDI3MTdaMIG3MT8wPQYDVQQDDDZUw5xSS1RSVVNUIEVsZWt0cm9uaWsgU2Vy +dGlmaWthIEhpem1ldCBTYcSfbGF5xLFjxLFzxLExCzAJBgNVBAYMAlRSMQ8wDQYD +VQQHDAZBTktBUkExVjBUBgNVBAoMTShjKSAyMDA1IFTDnFJLVFJVU1QgQmlsZ2kg +xLBsZXRpxZ9pbSB2ZSBCaWxpxZ9pbSBHw7x2ZW5sacSfaSBIaXptZXRsZXJpIEEu +xZ4uMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAylIF1mMD2Bxf3dJ7 +XfIMYGFbazt0K3gNfUW9InTojAPBxhEqPZW8qZSwu5GXyGl8hMW0kWxsE2qkVa2k +heiVfrMArwDCBRj1cJ02i67L5BuBf5OI+2pVu32Fks66WJ/bMsW9Xe8iSi9BB35J +YbOG7E6mQW6EvAPs9TscyB/C7qju6hJKjRTP8wrgUDn5CDX4EVmt5yLqS8oUBt5C +urKZ8y1UiBAG6uEaPj1nH/vO+3yC6BFdSsG5FOpU2WabfIl9BJpiyelSPJ6c79L1 +JuTm5Rh8i27fbMx4W09ysstcP4wFjdFMjK2Sx+F4f2VsSQZQLJ4ywtdKxnWKWU51 +b0dewQIDAQABoxAwDjAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBBQUAA4IBAQAV +9VX/N5aAWSGk/KEVTCD21F/aAyT8z5Aa9CEKmu46sWrv7/hg0Uw2ZkUd82YCdAR7 +kjCo3gp2D++Vbr3JN+YaDayJSFvMgzbC9UZcWYJWtNX+I7TYVBxEq8Sn5RTOPEFh +fEPmzcSBCYsk+1Ql1haolgxnB2+zUEfjHCQo3SqYpGH+2+oSN7wBGjSFvW5P55Fy +B0SFHljKVETd96y5y4khctuPwGkplyqjrhgjlxxBKot8KsF8kOipKMDTkcatKIdA +aLX/7KfS0zgYnNN9aV3wxqUeJBujR/xpB2jn5Jq07Q+hh4cCzofSSE7hvP/L8XKS +RGQDJereW26fyfJOrN3H +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEPTCCAyWgAwIBAgIBATANBgkqhkiG9w0BAQUFADCBvzE/MD0GA1UEAww2VMOc +UktUUlVTVCBFbGVrdHJvbmlrIFNlcnRpZmlrYSBIaXptZXQgU2HEn2xhecSxY8Sx +c8SxMQswCQYDVQQGEwJUUjEPMA0GA1UEBwwGQW5rYXJhMV4wXAYDVQQKDFVUw5xS +S1RSVVNUIEJpbGdpIMSwbGV0acWfaW0gdmUgQmlsacWfaW0gR8O8dmVubGnEn2kg +SGl6bWV0bGVyaSBBLsWeLiAoYykgQXJhbMSxayAyMDA3MB4XDTA3MTIyNTE4Mzcx +OVoXDTE3MTIyMjE4MzcxOVowgb8xPzA9BgNVBAMMNlTDnFJLVFJVU1QgRWxla3Ry +b25payBTZXJ0aWZpa2EgSGl6bWV0IFNhxJ9sYXnEsWPEsXPEsTELMAkGA1UEBhMC +VFIxDzANBgNVBAcMBkFua2FyYTFeMFwGA1UECgxVVMOcUktUUlVTVCBCaWxnaSDE +sGxldGnFn2ltIHZlIEJpbGnFn2ltIEfDvHZlbmxpxJ9pIEhpem1ldGxlcmkgQS7F +ni4gKGMpIEFyYWzEsWsgMjAwNzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC +ggEBAKu3PgqMyKVYFeaK7yc9SrToJdPNM8Ig3BnuiD9NYvDdE3ePYakqtdTyuTFY +KTsvP2qcb3N2Je40IIDu6rfwxArNK4aUyeNgsURSsloptJGXg9i3phQvKUmi8wUG ++7RP2qFsmmaf8EMJyupyj+sA1zU511YXRxcw9L6/P8JorzZAwan0qafoEGsIiveG +HtyaKhUG9qPw9ODHFNRRf8+0222vR5YXm3dx2KdxnSQM9pQ/hTEST7ruToK4uT6P +IzdezKKqdfcYbwnTrqdUKDT74eA7YH2gvnmJhsifLfkKS8RQouf9eRbHegsYz85M +733WB2+Y8a+xwXrXgTW4qhe04MsCAwEAAaNCMEAwHQYDVR0OBBYEFCnFkKslrxHk +Yb+j/4hhkeYO/pyBMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MA0G +CSqGSIb3DQEBBQUAA4IBAQAQDdr4Ouwo0RSVgrESLFF6QSU2TJ/sPx+EnWVUXKgW +AkD6bho3hO9ynYYKVZ1WKKxmLNA6VpM0ByWtCLCPyA8JWcqdmBzlVPi5RX9ql2+I +aE1KBiY3iAIOtsbWcpnOa3faYjGkVh+uX4132l32iPwa2Z61gfAyuOOI0JzzaqC5 +mxRZNTZPz/OOXl0XrRWV2N2y1RVuAE6zS89mlOTgzbUF2mNXi+WzqtvALhyQRNsa +XRik7r4EW5nVcV9VZWRi1aKbBFmGyGJ353yCRWo9F7/snXUMrqNvWtMvmDb08PUZ +qxFdyKbjKlhqQgnDvZImZjINXQhVdP+MmNAKpoRq0Tl9 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEPDCCAySgAwIBAgIBATANBgkqhkiG9w0BAQUFADCBvjE/MD0GA1UEAww2VMOc +UktUUlVTVCBFbGVrdHJvbmlrIFNlcnRpZmlrYSBIaXptZXQgU2HEn2xhecSxY8Sx +c8SxMQswCQYDVQQGEwJUUjEPMA0GA1UEBwwGQW5rYXJhMV0wWwYDVQQKDFRUw5xS +S1RSVVNUIEJpbGdpIMSwbGV0acWfaW0gdmUgQmlsacWfaW0gR8O8dmVubGnEn2kg +SGl6bWV0bGVyaSBBLsWeLiAoYykgS2FzxLFtIDIwMDUwHhcNMDUxMTA3MTAwNzU3 +WhcNMTUwOTE2MTAwNzU3WjCBvjE/MD0GA1UEAww2VMOcUktUUlVTVCBFbGVrdHJv +bmlrIFNlcnRpZmlrYSBIaXptZXQgU2HEn2xhecSxY8Sxc8SxMQswCQYDVQQGEwJU +UjEPMA0GA1UEBwwGQW5rYXJhMV0wWwYDVQQKDFRUw5xSS1RSVVNUIEJpbGdpIMSw +bGV0acWfaW0gdmUgQmlsacWfaW0gR8O8dmVubGnEn2kgSGl6bWV0bGVyaSBBLsWe +LiAoYykgS2FzxLFtIDIwMDUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB +AQCpNn7DkUNMwxmYCMjHWHtPFoylzkkBH3MOrHUTpvqeLCDe2JAOCtFp0if7qnef +J1Il4std2NiDUBd9irWCPwSOtNXwSadktx4uXyCcUHVPr+G1QRT0mJKIx+XlZEdh +R3n9wFHxwZnn3M5q+6+1ATDcRhzviuyV79z/rxAc653YsKpqhRgNF8k+v/Gb0AmJ +Qv2gQrSdiVFVKc8bcLyEVK3BEx+Y9C52YItdP5qtygy/p1Zbj3e41Z55SZI/4PGX +JHpsmxcPbe9TmJEr5A++WXkHeLuXlfSfadRYhwqp48y2WBmfJiGxxFmNskF1wK1p +zpwACPI2/z7woQ8arBT9pmAPAgMBAAGjQzBBMB0GA1UdDgQWBBTZN7NOBf3Zz58S +Fq62iS/rJTqIHDAPBgNVHQ8BAf8EBQMDBwYAMA8GA1UdEwEB/wQFMAMBAf8wDQYJ +KoZIhvcNAQEFBQADggEBAHJglrfJ3NgpXiOFX7KzLXb7iNcX/nttRbj2hWyfIvwq +ECLsqrkw9qtY1jkQMZkpAL2JZkH7dN6RwRgLn7Vhy506vvWolKMiVW4XSf/SKfE4 +Jl3vpao6+XF75tpYHdN0wgH6PmlYX63LaL4ULptswLbcoCb6dxriJNoaN+BnrdFz +gw2lGh1uEpJ+hGIAF728JRhX8tepb1mIvDS3LoV4nZbcFMMsilKbloxSZj2GFotH +uFEJjOp9zYhys2AzsfAKRO8P9Qk3iCQOLGsgOqL6EfJANZxEaGM7rDNvY7wsu/LS +y3Z9fYjYHcgFHW68lKlmjHdxx/qR+i9Rnuk5UrbnBEI= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFQTCCAymgAwIBAgICDL4wDQYJKoZIhvcNAQELBQAwUTELMAkGA1UEBhMCVFcx +EjAQBgNVBAoTCVRBSVdBTi1DQTEQMA4GA1UECxMHUm9vdCBDQTEcMBoGA1UEAxMT +VFdDQSBHbG9iYWwgUm9vdCBDQTAeFw0xMjA2MjcwNjI4MzNaFw0zMDEyMzExNTU5 +NTlaMFExCzAJBgNVBAYTAlRXMRIwEAYDVQQKEwlUQUlXQU4tQ0ExEDAOBgNVBAsT +B1Jvb3QgQ0ExHDAaBgNVBAMTE1RXQ0EgR2xvYmFsIFJvb3QgQ0EwggIiMA0GCSqG +SIb3DQEBAQUAA4ICDwAwggIKAoICAQCwBdvI64zEbooh745NnHEKH1Jw7W2CnJfF +10xORUnLQEK1EjRsGcJ0pDFfhQKX7EMzClPSnIyOt7h52yvVavKOZsTuKwEHktSz +0ALfUPZVr2YOy+BHYC8rMjk1Ujoog/h7FsYYuGLWRyWRzvAZEk2tY/XTP3VfKfCh +MBwqoJimFb3u/Rk28OKRQ4/6ytYQJ0lM793B8YVwm8rqqFpD/G2Gb3PpN0Wp8DbH +zIh1HrtsBv+baz4X7GGqcXzGHaL3SekVtTzWoWH1EfcFbx39Eb7QMAfCKbAJTibc +46KokWofwpFFiFzlmLhxpRUZyXx1EcxwdE8tmx2RRP1WKKD+u4ZqyPpcC1jcxkt2 +yKsi2XMPpfRaAok/T54igu6idFMqPVMnaR1sjjIsZAAmY2E2TqNGtz99sy2sbZCi +laLOz9qC5wc0GZbpuCGqKX6mOL6OKUohZnkfs8O1CWfe1tQHRvMq2uYiN2DLgbYP +oA/pyJV/v1WRBXrPPRXAb94JlAGD1zQbzECl8LibZ9WYkTunhHiVJqRaCPgrdLQA +BDzfuBSO6N+pjWxnkjMdwLfS7JLIvgm/LCkFbwJrnu+8vyq8W8BQj0FwcYeyTbcE +qYSjMq+u7msXi7Kx/mzhkIyIqJdIzshNy/MGz19qCkKxHh53L46g5pIOBvwFItIm +4TFRfTLcDwIDAQABoyMwITAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB +/zANBgkqhkiG9w0BAQsFAAOCAgEAXzSBdu+WHdXltdkCY4QWwa6gcFGn90xHNcgL +1yg9iXHZqjNB6hQbbCEAwGxCGX6faVsgQt+i0trEfJdLjbDorMjupWkEmQqSpqsn +LhpNgb+E1HAerUf+/UqdM+DyucRFCCEK2mlpc3INvjT+lIutwx4116KD7+U4x6WF +H6vPNOw/KP4M8VeGTslV9xzU2KV9Bnpv1d8Q34FOIWWxtuEXeZVFBs5fzNxGiWNo +RI2T9GRwoD2dKAXDOXC4Ynsg/eTb6QihuJ49CcdP+yz4k3ZB3lLg4VfSnQO8d57+ +nile98FRYB/e2guyLXW3Q0iT5/Z5xoRdgFlglPx4mI88k1HtQJAH32RjJMtOcQWh +15QaiDLxInQirqWm2BJpTGCjAu4r7NRjkgtevi92a6O2JryPA9gK8kxkRr05YuWW +6zRjESjMlfGt7+/cgFhI6Uu46mWs6fyAtbXIRfmswZ/ZuepiiI7E8UuDEq3mi4TW +nsLrgxifarsbJGAzcMzs9zLzXNl5fe+epP7JI8Mk7hWSsT2RTyaGvWZzJBPqpK5j +wa19hAM8EHiGG3njxPPyBJUgriOCxLM6AGK/5jYk4Ve6xx6QddVfP5VhK8E7zeWz +aGHQRiapIVJpLesux+t3zqY6tQMzT3bR51xUAV3LePTJDL/PEo4XLSNolOer/qmy +KwbQBM0= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDezCCAmOgAwIBAgIBATANBgkqhkiG9w0BAQUFADBfMQswCQYDVQQGEwJUVzES +MBAGA1UECgwJVEFJV0FOLUNBMRAwDgYDVQQLDAdSb290IENBMSowKAYDVQQDDCFU +V0NBIFJvb3QgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDgwODI4MDcyNDMz +WhcNMzAxMjMxMTU1OTU5WjBfMQswCQYDVQQGEwJUVzESMBAGA1UECgwJVEFJV0FO +LUNBMRAwDgYDVQQLDAdSb290IENBMSowKAYDVQQDDCFUV0NBIFJvb3QgQ2VydGlm +aWNhdGlvbiBBdXRob3JpdHkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB +AQCwfnK4pAOU5qfeCTiRShFAh6d8WWQUe7UREN3+v9XAu1bihSX0NXIP+FPQQeFE +AcK0HMMxQhZHhTMidrIKbw/lJVBPhYa+v5guEGcevhEFhgWQxFnQfHgQsIBct+HH +K3XLfJ+utdGdIzdjp9xCoi2SBBtQwXu4PhvJVgSLL1KbralW6cH/ralYhzC2gfeX +RfwZVzsrb+RH9JlF/h3x+JejiB03HFyP4HYlmlD4oFT/RJB2I9IyxsOrBr/8+7/z +rX2SYgJbKdM1o5OaQ2RgXbL6Mv87BK9NQGr5x+PvI/1ry+UPizgN7gr8/g+YnzAx +3WxSZfmLgb4i4RxYA7qRG4kHAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV +HRMBAf8EBTADAQH/MB0GA1UdDgQWBBRqOFsmjd6LWvJPelSDGRjjCDWmujANBgkq +hkiG9w0BAQUFAAOCAQEAPNV3PdrfibqHDAhUaiBQkr6wQT25JmSDCi/oQMCXKCeC +MErJk/9q56YAf4lCmtYR5VPOL8zy2gXE/uJQxDqGfczafhAJO5I1KlOy/usrBdls +XebQ79NqZp4VKIV66IIArB6nCWlWQtNoURi+VJq/REG6Sb4gumlc7rh3zc5sH62D +lhh9DrUUOYTxKOkto557HnpyWoOzeW/vtPzQCqVYT0bf+215WfKEIlKuD8z7fDvn +aspHYcN6+NOSBB+4IIThNlQWx0DeO4pz3N/GCUzf7Nr/1FNCocnyYh0igzyXxfkZ +YiesZSLX0zzG5Y6yU8xJzrww/nsOM5D77dIUkR8Hrw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFcjCCA1qgAwIBAgIQH51ZWtcvwgZEpYAIaeNe9jANBgkqhkiG9w0BAQUFADA/ +MQswCQYDVQQGEwJUVzEwMC4GA1UECgwnR292ZXJubWVudCBSb290IENlcnRpZmlj +YXRpb24gQXV0aG9yaXR5MB4XDTAyMTIwNTEzMjMzM1oXDTMyMTIwNTEzMjMzM1ow +PzELMAkGA1UEBhMCVFcxMDAuBgNVBAoMJ0dvdmVybm1lbnQgUm9vdCBDZXJ0aWZp +Y2F0aW9uIEF1dGhvcml0eTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIB +AJoluOzMonWoe/fOW1mKydGGEghU7Jzy50b2iPN86aXfTEc2pBsBHH8eV4qNw8XR +IePaJD9IK/ufLqGU5ywck9G/GwGHU5nOp/UKIXZ3/6m3xnOUT0b3EEk3+qhZSV1q +gQdW8or5BtD3cCJNtLdBuTK4sfCxw5w/cP1T3YGq2GN49thTbqGsaoQkclSGxtKy +yhwOeYHWtXBiCAEuTk8O1RGvqa/lmr/czIdtJuTJV6L7lvnM4T9TjGxMfptTCAts +F/tnyMKtsc2AtJfcdgEWFelq16TheEfOhtX7MfP6Mb40qij7cEwdScevLJ1tZqa2 +jWR+tSBqnTuBto9AAGdLiYa4zGX+FVPpBMHWXx1E1wovJ5pGfaENda1UhhXcSTvx +ls4Pm6Dso3pdvtUqdULle96ltqqvKKyskKw4t9VoNSZ63Pc78/1Fm9G7Q3hub/FC +VGqY8A2tl+lSXunVanLeavcbYBT0peS2cWeqH+riTcFCQP5nRhc4L0c/cZyu5SHK +YS1tB6iEfC3uUSXxY5Ce/eFXiGvviiNtsea9P63RPZYLhY3Naye7twWb7LuRqQoH +EgKXTiCQ8P8NHuJBO9NAOueNXdpm5AKwB1KYXA6OM5zCppX7VRluTI6uSw+9wThN +Xo+EHWbNxWCWtFJaBYmOlXqYwZE8lSOyDvR5tMl8wUohAgMBAAGjajBoMB0GA1Ud +DgQWBBTMzO/MKWCkO7GStjz6MmKPrCUVOzAMBgNVHRMEBTADAQH/MDkGBGcqBwAE +MTAvMC0CAQAwCQYFKw4DAhoFADAHBgVnKgMAAAQUA5vwIhP/lSg209yewDL7MTqK +UWUwDQYJKoZIhvcNAQEFBQADggIBAECASvomyc5eMN1PhnR2WPWus4MzeKR6dBcZ +TulStbngCnRiqmjKeKBMmo4sIy7VahIkv9Ro04rQ2JyftB8M3jh+Vzj8jeJPXgyf +qzvS/3WXy6TjZwj/5cAWtUgBfen5Cv8b5Wppv3ghqMKnI6mGq3ZW6A4M9hPdKmaK +ZEk9GhiHkASfQlK3T8v+R0F2Ne//AHY2RTKbxkaFXeIksB7jSJaYV0eUVXoPQbFE +JPPB/hprv4j9wabak2BegUqZIJxIZhm1AHlUD7gsL0u8qV1bYH+Mh6XgUmMqvtg7 +hUAV/h62ZT/FS9p+tXo1KaMuephgIqP0fSdOLeq0dDzpD6QzDxARvBMB1uUO07+1 +EqLhRSPAzAhuYbeJq4PjJB7mXQfnHyA+z2fI56wwbSdLaG5LKlwCCDTb+HbkZ6Mm +nD+iMsJKxYEYMRBWqoTvLQr/uB930r+lWKBi5NdLkXWNiYCYfm3LU05er/ayl4WX +udpVBrkk7tfGOB5jGxI7leFYrPLfhNVfmS8NVVvmONsuP3LpSIXLuykTjx44Vbnz +ssQwmSNOXfJIoRIM3BKQCZBUkQM8R+XVyWXgt0t97EfTsws+rZ7QdAAO671RrcDe +LMDDav7v3Aun+kbfYNucpllQdSNpc5Oy+fwC00fmcc4QAu4njIT/rEUNE1yDMuAl +pYYsfPQS +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFODCCAyCgAwIBAgIRAJW+FqD3LkbxezmCcvqLzZYwDQYJKoZIhvcNAQEFBQAw +NzEUMBIGA1UECgwLVGVsaWFTb25lcmExHzAdBgNVBAMMFlRlbGlhU29uZXJhIFJv +b3QgQ0EgdjEwHhcNMDcxMDE4MTIwMDUwWhcNMzIxMDE4MTIwMDUwWjA3MRQwEgYD +VQQKDAtUZWxpYVNvbmVyYTEfMB0GA1UEAwwWVGVsaWFTb25lcmEgUm9vdCBDQSB2 +MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMK+6yfwIaPzaSZVfp3F +VRaRXP3vIb9TgHot0pGMYzHw7CTww6XScnwQbfQ3t+XmfHnqjLWCi65ItqwA3GV1 +7CpNX8GH9SBlK4GoRz6JI5UwFpB/6FcHSOcZrr9FZ7E3GwYq/t75rH2D+1665I+X +Z75Ljo1kB1c4VWk0Nj0TSO9P4tNmHqTPGrdeNjPUtAa9GAH9d4RQAEX1jF3oI7x+ +/jXh7VB7qTCNGdMJjmhnXb88lxhTuylixcpecsHHltTbLaC0H2kD7OriUPEMPPCs +81Mt8Bz17Ww5OXOAFshSsCPN4D7c3TxHoLs1iuKYaIu+5b9y7tL6pe0S7fyYGKkm +dtwoSxAgHNN/Fnct7W+A90m7UwW7XWjH1Mh1Fj+JWov3F0fUTPHSiXk+TT2YqGHe +Oh7S+F4D4MHJHIzTjU3TlTazN19jY5szFPAtJmtTfImMMsJu7D0hADnJoWjiUIMu +sDor8zagrC/kb2HCUQk5PotTubtn2txTuXZZNp1D5SDgPTJghSJRt8czu90VL6R4 +pgd7gUY2BIbdeTXHlSw7sKMXNeVzH7RcWe/a6hBle3rQf5+ztCo3O3CLm1u5K7fs +slESl1MpWtTwEhDcTwK7EpIvYtQ/aUN8Ddb8WHUBiJ1YFkveupD/RwGJBmr2X7KQ +arMCpgKIv7NHfirZ1fpoeDVNAgMBAAGjPzA9MA8GA1UdEwEB/wQFMAMBAf8wCwYD +VR0PBAQDAgEGMB0GA1UdDgQWBBTwj1k4ALP1j5qWDNXr+nuqF+gTEjANBgkqhkiG +9w0BAQUFAAOCAgEAvuRcYk4k9AwI//DTDGjkk0kiP0Qnb7tt3oNmzqjMDfz1mgbl +dxSR651Be5kqhOX//CHBXfDkH1e3damhXwIm/9fH907eT/j3HEbAek9ALCI18Bmx +0GtnLLCo4MBANzX2hFxc469CeP6nyQ1Q6g2EdvZR74NTxnr/DlZJLo961gzmJ1Tj +TQpgcmLNkQfWpb/ImWvtxBnmq0wROMVvMeJuScg/doAmAyYp4Db29iBT4xdwNBed +Y2gea+zDTYa4EzAvXUYNR0PVG6pZDrlcjQZIrXSHX8f8MVRBE+LHIQ6e4B4N4cB7 +Q4WQxYpYxmUKeFfyxiMPAdkgS94P+5KFdSpcc41teyWRyu5FrgZLAMzTsVlQ2jqI +OylDRl6XK1TOU2+NSueW+r9xDkKLfP0ooNBIytrEgUy7onOTJsjrDNYmiLbAJM+7 +vVvrdX3pCI6GMyx5dwlppYn8s3CQh3aP0yK7Qs69cwsgJirQmz1wHiRszYd2qReW +t88NkvuOGKmYSdGe/mBEciG5Ge3C9THxOUiIkCR1VBatzvT4aRRkOfujuLpwQMcn +HL/EVlP6Y2XQ8xwOFvVrhlhNGNTkDY6lnVuR3HYkUD/GKvvZt5y11ubQ2egZixVx +SK236thZiNSQvxaz2emsWWFUyBy6ysHK4bkgTI86k4mloMy/0/Z1pHWWbVY= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDJzCCApCgAwIBAgIBATANBgkqhkiG9w0BAQQFADCBzjELMAkGA1UEBhMCWkEx +FTATBgNVBAgTDFdlc3Rlcm4gQ2FwZTESMBAGA1UEBxMJQ2FwZSBUb3duMR0wGwYD +VQQKExRUaGF3dGUgQ29uc3VsdGluZyBjYzEoMCYGA1UECxMfQ2VydGlmaWNhdGlv +biBTZXJ2aWNlcyBEaXZpc2lvbjEhMB8GA1UEAxMYVGhhd3RlIFByZW1pdW0gU2Vy +dmVyIENBMSgwJgYJKoZIhvcNAQkBFhlwcmVtaXVtLXNlcnZlckB0aGF3dGUuY29t +MB4XDTk2MDgwMTAwMDAwMFoXDTIwMTIzMTIzNTk1OVowgc4xCzAJBgNVBAYTAlpB +MRUwEwYDVQQIEwxXZXN0ZXJuIENhcGUxEjAQBgNVBAcTCUNhcGUgVG93bjEdMBsG +A1UEChMUVGhhd3RlIENvbnN1bHRpbmcgY2MxKDAmBgNVBAsTH0NlcnRpZmljYXRp +b24gU2VydmljZXMgRGl2aXNpb24xITAfBgNVBAMTGFRoYXd0ZSBQcmVtaXVtIFNl +cnZlciBDQTEoMCYGCSqGSIb3DQEJARYZcHJlbWl1bS1zZXJ2ZXJAdGhhd3RlLmNv +bTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA0jY2aovXwlue2oFBYo847kkE +VdbQ7xwblRZH7xhINTpS9CtqBo87L+pW46+GjZ4X9560ZXUCTe/LCaIhUdib0GfQ +ug2SBhRz1JPLlyoAnFxODLz6FVL88kRu2hFKbgifLy3j+ao6hnO2RlNYyIkFvYMR +uHM/qgeN9EJN50CdHDcCAwEAAaMTMBEwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG +9w0BAQQFAAOBgQAmSCwWwlj66BZ0DKqqX1Q/8tfJeGBeXm43YyJ3Nn6yF8Q0ufUI +hfzJATj/Tb7yFkJD57taRvvBxhEf8UqwKEbJw8RCfbz6q1lu1bdRiBHjpIUZa4JM +pAwSremkrj/xw0llmozFyD4lt5SZu5IycQfwhl7tUCemDaYj+bvLpgcUQg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDEzCCAnygAwIBAgIBATANBgkqhkiG9w0BAQQFADCBxDELMAkGA1UEBhMCWkEx +FTATBgNVBAgTDFdlc3Rlcm4gQ2FwZTESMBAGA1UEBxMJQ2FwZSBUb3duMR0wGwYD +VQQKExRUaGF3dGUgQ29uc3VsdGluZyBjYzEoMCYGA1UECxMfQ2VydGlmaWNhdGlv +biBTZXJ2aWNlcyBEaXZpc2lvbjEZMBcGA1UEAxMQVGhhd3RlIFNlcnZlciBDQTEm +MCQGCSqGSIb3DQEJARYXc2VydmVyLWNlcnRzQHRoYXd0ZS5jb20wHhcNOTYwODAx +MDAwMDAwWhcNMjAxMjMxMjM1OTU5WjCBxDELMAkGA1UEBhMCWkExFTATBgNVBAgT +DFdlc3Rlcm4gQ2FwZTESMBAGA1UEBxMJQ2FwZSBUb3duMR0wGwYDVQQKExRUaGF3 +dGUgQ29uc3VsdGluZyBjYzEoMCYGA1UECxMfQ2VydGlmaWNhdGlvbiBTZXJ2aWNl +cyBEaXZpc2lvbjEZMBcGA1UEAxMQVGhhd3RlIFNlcnZlciBDQTEmMCQGCSqGSIb3 +DQEJARYXc2VydmVyLWNlcnRzQHRoYXd0ZS5jb20wgZ8wDQYJKoZIhvcNAQEBBQAD +gY0AMIGJAoGBANOkUG7I/1Zr5s9dtuoMaHVHoqrC2oQl/Kj0R1HahbUgdJSGHg91 +yekIYfUGbTBuFRkC6VLAYttNmZ7iagxEOM3+vuNkCXDF/rFrKbYvScg71CcEJRCX +L+eQbcAoQpnXTEPew/UhbVSfXcNY4cDk2VuwuNy0e982OsK1ZiIS1ocNAgMBAAGj +EzARMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEEBQADgYEAB/pMaVz7lcxG +7oWDTSEwjsrZqG9JGubaUeNgcGyEYRGhGshIPllDfU+VPaGLtwtimHp1it2ITk6e +QNuozDJ0uW8NxuOzRAvZim+aKZuZGCg70eNAKJpaPNW15yAbi8qkq43pUdniTCxZ +qdq5snUb9kLy78fyGPmJvKP/iiMucEc= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDZzCCAk+gAwIBAgIQGx+ttiD5JNM2a/fH8YygWTANBgkqhkiG9w0BAQUFADBF +MQswCQYDVQQGEwJHQjEYMBYGA1UEChMPVHJ1c3RpcyBMaW1pdGVkMRwwGgYDVQQL +ExNUcnVzdGlzIEZQUyBSb290IENBMB4XDTAzMTIyMzEyMTQwNloXDTI0MDEyMTEx +MzY1NFowRTELMAkGA1UEBhMCR0IxGDAWBgNVBAoTD1RydXN0aXMgTGltaXRlZDEc +MBoGA1UECxMTVHJ1c3RpcyBGUFMgUm9vdCBDQTCCASIwDQYJKoZIhvcNAQEBBQAD +ggEPADCCAQoCggEBAMVQe547NdDfxIzNjpvto8A2mfRC6qc+gIMPpqdZh8mQRUN+ +AOqGeSoDvT03mYlmt+WKVoaTnGhLaASMk5MCPjDSNzoiYYkchU59j9WvezX2fihH +iTHcDnlkH5nSW7r+f2C/revnPDgpai/lkQtV/+xvWNUtyd5MZnGPDNcE2gfmHhjj +vSkCqPoc4Vu5g6hBSLwacY3nYuUtsuvffM/bq1rKMfFMIvMFE/eC+XN5DL7XSxzA +0RU8k0Fk0ea+IxciAIleH2ulrG6nS4zto3Lmr2NNL4XSFDWaLk6M6jKYKIahkQlB +OrTh4/L68MkKokHdqeMDx4gVOxzUGpTXn2RZEm0CAwEAAaNTMFEwDwYDVR0TAQH/ +BAUwAwEB/zAfBgNVHSMEGDAWgBS6+nEleYtXQSUhhgtx67JkDoshZzAdBgNVHQ4E +FgQUuvpxJXmLV0ElIYYLceuyZA6LIWcwDQYJKoZIhvcNAQEFBQADggEBAH5Y//01 +GX2cGE+esCu8jowU/yyg2kdbw++BLa8F6nRIW/M+TgfHbcWzk88iNVy2P3UnXwmW +zaD+vkAMXBJV+JOCyinpXj9WV4s4NvdFGkwozZ5BuO1WTISkQMi4sKUraXAEasP4 +1BIy+Q7DsdwyhEQsb8tGD+pmQQ9P8Vilpg0ND2HepZ5dfWWhPBfnqFVO76DH7cZE +f1T1o+CP8HxVIo8ptoGj4W1OLBuAZ+ytIJ8MYmHVl/9D7S3B2l0pKoU/rGXuhg8F +jZBf3+6f9L/uHfuY5H+QK4R4EA5sSVPvFVtlRkpdr7r7OnIdzfYliB6XzCGcKQEN +ZetX2fNXlrtIzYE= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFFzCCA/+gAwIBAgIBETANBgkqhkiG9w0BAQUFADCCASsxCzAJBgNVBAYTAlRS +MRgwFgYDVQQHDA9HZWJ6ZSAtIEtvY2FlbGkxRzBFBgNVBAoMPlTDvHJraXllIEJp +bGltc2VsIHZlIFRla25vbG9qaWsgQXJhxZ90xLFybWEgS3VydW11IC0gVMOcQsSw +VEFLMUgwRgYDVQQLDD9VbHVzYWwgRWxla3Ryb25payB2ZSBLcmlwdG9sb2ppIEFy +YcWfdMSxcm1hIEVuc3RpdMO8c8O8IC0gVUVLQUUxIzAhBgNVBAsMGkthbXUgU2Vy +dGlmaWthc3lvbiBNZXJrZXppMUowSAYDVQQDDEFUw5xCxLBUQUsgVUVLQUUgS8O2 +ayBTZXJ0aWZpa2EgSGl6bWV0IFNhxJ9sYXnEsWPEsXPEsSAtIFPDvHLDvG0gMzAe +Fw0wNzA4MjQxMTM3MDdaFw0xNzA4MjExMTM3MDdaMIIBKzELMAkGA1UEBhMCVFIx +GDAWBgNVBAcMD0dlYnplIC0gS29jYWVsaTFHMEUGA1UECgw+VMO8cmtpeWUgQmls +aW1zZWwgdmUgVGVrbm9sb2ppayBBcmHFn3TEsXJtYSBLdXJ1bXUgLSBUw5xCxLBU +QUsxSDBGBgNVBAsMP1VsdXNhbCBFbGVrdHJvbmlrIHZlIEtyaXB0b2xvamkgQXJh +xZ90xLFybWEgRW5zdGl0w7xzw7wgLSBVRUtBRTEjMCEGA1UECwwaS2FtdSBTZXJ0 +aWZpa2FzeW9uIE1lcmtlemkxSjBIBgNVBAMMQVTDnELEsFRBSyBVRUtBRSBLw7Zr +IFNlcnRpZmlrYSBIaXptZXQgU2HEn2xhecSxY8Sxc8SxIC0gU8O8csO8bSAzMIIB +IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAim1L/xCIOsP2fpTo6iBkcK4h +gb46ezzb8R1Sf1n68yJMlaCQvEhOEav7t7WNeoMojCZG2E6VQIdhn8WebYGHV2yK +O7Rm6sxA/OOqbLLLAdsyv9Lrhc+hDVXDWzhXcLh1xnnRFDDtG1hba+818qEhTsXO +fJlfbLm4IpNQp81McGq+agV/E5wrHur+R84EpW+sky58K5+eeROR6Oqeyjh1jmKw +lZMq5d/pXpduIF9fhHpEORlAHLpVK/swsoHvhOPc7Jg4OQOFCKlUAwUp8MmPi+oL +hmUZEdPpCSPeaJMDyTYcIW7OjGbxmTDY17PDHfiBLqi9ggtm/oLL4eAagsNAgQID +AQABo0IwQDAdBgNVHQ4EFgQUvYiHyY/2pAoLquvF/pEjnatKijIwDgYDVR0PAQH/ +BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEFBQADggEBAB18+kmP +NOm3JpIWmgV050vQbTlswyb2zrgxvMTfvCr4N5EY3ATIZJkrGG2AA1nJrvhY0D7t +wyOfaTyGOBye79oneNGEN3GKPEs5z35FBtYt2IpNeBLWrcLTy9LQQfMmNkqblWwM +7uXRQydmwYj3erMgbOqwaSvHIOgMA8RBBZniP+Rr+KCGgceExh/VS4ESshYhLBOh +gLJeDEoTniDYYkCrkOpkSi+sDQESeUWoL4cZaMjihccwsnX5OD+ywJO0a+IDRM5n +oN+J1q2MdqMTw5RhK2vZbMEHCiIHhWyFJEapvj+LeISCfiQMnf2BN+MlqO02TpUs +yZyQ2uypQjyttgI= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICjzCCAhWgAwIBAgIQXIuZxVqUxdJxVt7NiYDMJjAKBggqhkjOPQQDAzCBiDEL +MAkGA1UEBhMCVVMxEzARBgNVBAgTCk5ldyBKZXJzZXkxFDASBgNVBAcTC0plcnNl +eSBDaXR5MR4wHAYDVQQKExVUaGUgVVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNVBAMT +JVVTRVJUcnVzdCBFQ0MgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMTAwMjAx +MDAwMDAwWhcNMzgwMTE4MjM1OTU5WjCBiDELMAkGA1UEBhMCVVMxEzARBgNVBAgT +Ck5ldyBKZXJzZXkxFDASBgNVBAcTC0plcnNleSBDaXR5MR4wHAYDVQQKExVUaGUg +VVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNVBAMTJVVTRVJUcnVzdCBFQ0MgQ2VydGlm +aWNhdGlvbiBBdXRob3JpdHkwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQarFRaqflo +I+d61SRvU8Za2EurxtW20eZzca7dnNYMYf3boIkDuAUU7FfO7l0/4iGzzvfUinng +o4N+LZfQYcTxmdwlkWOrfzCjtHDix6EznPO/LlxTsV+zfTJ/ijTjeXmjQjBAMB0G +A1UdDgQWBBQ64QmG1M8ZwpZ2dEl23OA1xmNjmjAOBgNVHQ8BAf8EBAMCAQYwDwYD +VR0TAQH/BAUwAwEB/zAKBggqhkjOPQQDAwNoADBlAjA2Z6EWCNzklwBBHU6+4WMB +zzuqQhFkoJ2UOQIReVx7Hfpkue4WQrO/isIJxOzksU0CMQDpKmFHjFJKS04YcPbW +RNZu9YO6bVi9JNlWSOrvxKJGgYhqOkbRqZtNyWHa0V1Xahg= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIF3jCCA8agAwIBAgIQAf1tMPyjylGoG7xkDjUDLTANBgkqhkiG9w0BAQwFADCB +iDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCk5ldyBKZXJzZXkxFDASBgNVBAcTC0pl +cnNleSBDaXR5MR4wHAYDVQQKExVUaGUgVVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNV +BAMTJVVTRVJUcnVzdCBSU0EgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMTAw +MjAxMDAwMDAwWhcNMzgwMTE4MjM1OTU5WjCBiDELMAkGA1UEBhMCVVMxEzARBgNV +BAgTCk5ldyBKZXJzZXkxFDASBgNVBAcTC0plcnNleSBDaXR5MR4wHAYDVQQKExVU +aGUgVVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNVBAMTJVVTRVJUcnVzdCBSU0EgQ2Vy +dGlmaWNhdGlvbiBBdXRob3JpdHkwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIK +AoICAQCAEmUXNg7D2wiz0KxXDXbtzSfTTK1Qg2HiqiBNCS1kCdzOiZ/MPans9s/B +3PHTsdZ7NygRK0faOca8Ohm0X6a9fZ2jY0K2dvKpOyuR+OJv0OwWIJAJPuLodMkY +tJHUYmTbf6MG8YgYapAiPLz+E/CHFHv25B+O1ORRxhFnRghRy4YUVD+8M/5+bJz/ +Fp0YvVGONaanZshyZ9shZrHUm3gDwFA66Mzw3LyeTP6vBZY1H1dat//O+T23LLb2 +VN3I5xI6Ta5MirdcmrS3ID3KfyI0rn47aGYBROcBTkZTmzNg95S+UzeQc0PzMsNT +79uq/nROacdrjGCT3sTHDN/hMq7MkztReJVni+49Vv4M0GkPGw/zJSZrM233bkf6 +c0Plfg6lZrEpfDKEY1WJxA3Bk1QwGROs0303p+tdOmw1XNtB1xLaqUkL39iAigmT +Yo61Zs8liM2EuLE/pDkP2QKe6xJMlXzzawWpXhaDzLhn4ugTncxbgtNMs+1b/97l +c6wjOy0AvzVVdAlJ2ElYGn+SNuZRkg7zJn0cTRe8yexDJtC/QV9AqURE9JnnV4ee +UB9XVKg+/XRjL7FQZQnmWEIuQxpMtPAlR1n6BB6T1CZGSlCBst6+eLf8ZxXhyVeE +Hg9j1uliutZfVS7qXMYoCAQlObgOK6nyTJccBz8NUvXt7y+CDwIDAQABo0IwQDAd +BgNVHQ4EFgQUU3m/WqorSs9UgOHYm8Cd8rIDZsswDgYDVR0PAQH/BAQDAgEGMA8G +A1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEMBQADggIBAFzUfA3P9wF9QZllDHPF +Up/L+M+ZBn8b2kMVn54CVVeWFPFSPCeHlCjtHzoBN6J2/FNQwISbxmtOuowhT6KO +VWKR82kV2LyI48SqC/3vqOlLVSoGIG1VeCkZ7l8wXEskEVX/JJpuXior7gtNn3/3 +ATiUFJVDBwn7YKnuHKsSjKCaXqeYalltiz8I+8jRRa8YFWSQEg9zKC7F4iRO/Fjs +8PRF/iKz6y+O0tlFYQXBl2+odnKPi4w2r78NBc5xjeambx9spnFixdjQg3IM8WcR +iQycE0xyNN+81XHfqnHd4blsjDwSXWXavVcStkNr/+XeTWYRUc+ZruwXtuhxkYze +Sf7dNXGiFSeUHM9h4ya7b6NnJSFd5t0dCy5oGzuCr+yDZ4XUmFF0sbmZgIn/f3gZ +XHlKYC6SQK5MNyosycdiyA5d9zZbyuAlJQG03RoHnHcAP9Dc1ew91Pq7P8yF1m9/ +qS3fuQL39ZeatTXaw2ewh0qpKJ4jjv9cJ2vhsE/zB+4ALtRZh8tSQZXq9EfX7mRB +VXyNWQKV3WKdwrnuWih0hKWbt5DHDAff9Yk2dDLWKMGwsAvgnEzDHNb842m1R0aB +L6KCq9NjRHDEjf8tM7qtj3u1cIiuPhnPQCjY/MiQu12ZIvVS5ljFH4gxQ+6IHdfG +jjxDah2nGN59PRbxYvnKkKj9 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEXjCCA0agAwIBAgIQRL4Mi1AAIbQR0ypoBqmtaTANBgkqhkiG9w0BAQUFADCB +kzELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2Ug +Q2l0eTEeMBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExho +dHRwOi8vd3d3LnVzZXJ0cnVzdC5jb20xGzAZBgNVBAMTElVUTiAtIERBVEFDb3Jw +IFNHQzAeFw05OTA2MjQxODU3MjFaFw0xOTA2MjQxOTA2MzBaMIGTMQswCQYDVQQG +EwJVUzELMAkGA1UECBMCVVQxFzAVBgNVBAcTDlNhbHQgTGFrZSBDaXR5MR4wHAYD +VQQKExVUaGUgVVNFUlRSVVNUIE5ldHdvcmsxITAfBgNVBAsTGGh0dHA6Ly93d3cu +dXNlcnRydXN0LmNvbTEbMBkGA1UEAxMSVVROIC0gREFUQUNvcnAgU0dDMIIBIjAN +BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA3+5YEKIrblXEjr8uRgnn4AgPLit6 +E5Qbvfa2gI5lBZMAHryv4g+OGQ0SR+ysraP6LnD43m77VkIVni5c7yPeIbkFdicZ +D0/Ww5y0vpQZY/KmEQrrU0icvvIpOxboGqBMpsn0GFlowHDyUwDAXlCCpVZvNvlK +4ESGoE1O1kduSUrLZ9emxAW5jh70/P/N5zbgnAVssjMiFdC04MwXwLLA9P4yPykq +lXvY8qdOD1R8oQ2AswkDwf9c3V6aPryuvEeKaq5xyh+xKrhfQgUL7EYw0XILyulW +bfXv33i+Ybqypa4ETLyorGkVl73v67SMvzX41MPRKA5cOp9wGDMgd8SirwIDAQAB +o4GrMIGoMAsGA1UdDwQEAwIBxjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRT +MtGzz3/64PGgXYVOktKeRR20TzA9BgNVHR8ENjA0MDKgMKAuhixodHRwOi8vY3Js +LnVzZXJ0cnVzdC5jb20vVVROLURBVEFDb3JwU0dDLmNybDAqBgNVHSUEIzAhBggr +BgEFBQcDAQYKKwYBBAGCNwoDAwYJYIZIAYb4QgQBMA0GCSqGSIb3DQEBBQUAA4IB +AQAnNZcAiosovcYzMB4p/OL31ZjUQLtgyr+rFywJNn9Q+kHcrpY6CiM+iVnJowft +Gzet/Hy+UUla3joKVAgWRcKZsYfNjGjgaQPpxE6YsjuMFrMOoAyYUJuTqXAJyCyj +j98C5OBxOvG0I3KgqgHf35g+FFCgMSa9KOlaMCZ1+XtgHI3zzVAmbQQnmt/VDUVH +KWss5nbZqSl9Mt3JNjy9rjXxEZ4du5A/EkdOjtd+D2JzHVImOBwYSf0wdJrE5SIv +2MCN7ZF6TACPcn9d2t0bi0Vr591pl6jFVkwPDPafepE39peC4N1xaf92P2BNPM/3 +mfnGV/TJVTl4uix5yaaIK/QI +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEdDCCA1ygAwIBAgIQRL4Mi1AAJLQR0zYq/mUK/TANBgkqhkiG9w0BAQUFADCB +lzELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2Ug +Q2l0eTEeMBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExho +dHRwOi8vd3d3LnVzZXJ0cnVzdC5jb20xHzAdBgNVBAMTFlVUTi1VU0VSRmlyc3Qt +SGFyZHdhcmUwHhcNOTkwNzA5MTgxMDQyWhcNMTkwNzA5MTgxOTIyWjCBlzELMAkG +A1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2UgQ2l0eTEe +MBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExhodHRwOi8v +d3d3LnVzZXJ0cnVzdC5jb20xHzAdBgNVBAMTFlVUTi1VU0VSRmlyc3QtSGFyZHdh +cmUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCx98M4P7Sof885glFn +0G2f0v9Y8+efK+wNiVSZuTiZFvfgIXlIwrthdBKWHTxqctU8EGc6Oe0rE81m65UJ +M6Rsl7HoxuzBdXmcRl6Nq9Bq/bkqVRcQVLMZ8Jr28bFdtqdt++BxF2uiiPsA3/4a +MXcMmgF6sTLjKwEHOG7DpV4jvEWbe1DByTCP2+UretNb+zNAHqDVmBe8i4fDidNd +oI6yqqr2jmmIBsX6iSHzCJ1pLgkzmykNRg+MzEk0sGlRvfkGzWitZky8PqxhvQqI +DsjfPe58BEydCl5rkdbux+0ojatNh4lz0G6k0B4WixThdkQDf2Os5M1JnMWS9Ksy +oUhbAgMBAAGjgbkwgbYwCwYDVR0PBAQDAgHGMA8GA1UdEwEB/wQFMAMBAf8wHQYD +VR0OBBYEFKFyXyYbKJhDlV0HN9WFlp1L0sNFMEQGA1UdHwQ9MDswOaA3oDWGM2h0 +dHA6Ly9jcmwudXNlcnRydXN0LmNvbS9VVE4tVVNFUkZpcnN0LUhhcmR3YXJlLmNy +bDAxBgNVHSUEKjAoBggrBgEFBQcDAQYIKwYBBQUHAwUGCCsGAQUFBwMGBggrBgEF +BQcDBzANBgkqhkiG9w0BAQUFAAOCAQEARxkP3nTGmZev/K0oXnWO6y1n7k57K9cM +//bey1WiCuFMVGWTYGufEpytXoMs61quwOQt9ABjHbjAbPLPSbtNk28Gpgoiskli +CE7/yMgUsogWXecB5BKV5UU0s4tpvc+0hY91UZ59Ojg6FEgSxvunOxqNDYJAB+gE +CJChicsZUN/KHAG8HQQZexB2lzvukJDKxA4fFm517zP4029bHpbj4HR3dHuKom4t +3XbWOTCC8KucUvIqx69JXn7HaOWCgchqJ/kniCrVWFCVH/A7HFe7fRQ5YiuayZSS +KqMiDP+JJn1fIytH1xUdqWqeUQ0qUZ6B+dQ7XnASfxAynB67nfhmqA== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIC5zCCAlACAQEwDQYJKoZIhvcNAQEFBQAwgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0 +IFZhbGlkYXRpb24gTmV0d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAz +BgNVBAsTLFZhbGlDZXJ0IENsYXNzIDEgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9y +aXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG +9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMB4XDTk5MDYyNTIyMjM0OFoXDTE5MDYy +NTIyMjM0OFowgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0IFZhbGlkYXRpb24gTmV0d29y +azEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENs +YXNzIDEgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9yaXR5MSEwHwYDVQQDExhodHRw +Oi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG9w0BCQEWEWluZm9AdmFsaWNl +cnQuY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDYWYJ6ibiWuqYvaG9Y +LqdUHAZu9OqNSLwxlBfw8068srg1knaw0KWlAdcAAxIiGQj4/xEjm84H9b9pGib+ +TunRf50sQB1ZaG6m+FiwnRqP0z/x3BkGgagO4DrdyFNFCQbmD3DD+kCmDuJWBQ8Y +TfwggtFzVXSNdnKgHZ0dwN0/cQIDAQABMA0GCSqGSIb3DQEBBQUAA4GBAFBoPUn0 +LBwGlN+VYH+Wexf+T3GtZMjdd9LvWVXoP+iOBSoh8gfStadS/pyxtuJbdxdA6nLW +I8sogTLDAHkY7FkXicnGah5xyf23dKUlRWnFSKsZ4UWKJWsZ7uW7EvV/96aNUcPw +nXS3qT6gpf+2SQMT2iLM7XGCK5nPOrf1LXLI +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIC5zCCAlACAQEwDQYJKoZIhvcNAQEFBQAwgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0 +IFZhbGlkYXRpb24gTmV0d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAz +BgNVBAsTLFZhbGlDZXJ0IENsYXNzIDIgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9y +aXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG +9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMB4XDTk5MDYyNjAwMTk1NFoXDTE5MDYy +NjAwMTk1NFowgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0IFZhbGlkYXRpb24gTmV0d29y +azEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENs +YXNzIDIgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9yaXR5MSEwHwYDVQQDExhodHRw +Oi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG9w0BCQEWEWluZm9AdmFsaWNl +cnQuY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDOOnHK5avIWZJV16vY +dA757tn2VUdZZUcOBVXc65g2PFxTXdMwzzjsvUGJ7SVCCSRrCl6zfN1SLUzm1NZ9 +WlmpZdRJEy0kTRxQb7XBhVQ7/nHk01xC+YDgkRoKWzk2Z/M/VXwbP7RfZHM047QS +v4dk+NoS/zcnwbNDu+97bi5p9wIDAQABMA0GCSqGSIb3DQEBBQUAA4GBADt/UG9v +UJSZSWI4OB9L+KXIPqeCgfYrx+jFzug6EILLGACOTb2oWH+heQC1u+mNr0HZDzTu +IYEZoDJJKPTEjlbVUjP9UNV+mWwD5MlM/Mtsq2azSiGM5bUMMj4QssxsodyamEwC +W/POuZ6lcg5Ktz885hZo+L7tdEy8W9ViH0Pd +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDhDCCAwqgAwIBAgIQL4D+I4wOIg9IZxIokYesszAKBggqhkjOPQQDAzCByjEL +MAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZW +ZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNyBWZXJpU2ln +biwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxWZXJp +U2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9y +aXR5IC0gRzQwHhcNMDcxMTA1MDAwMDAwWhcNMzgwMTE4MjM1OTU5WjCByjELMAkG +A1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZWZXJp +U2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNyBWZXJpU2lnbiwg +SW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxWZXJpU2ln +biBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5 +IC0gRzQwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAASnVnp8Utpkmw4tXNherJI9/gHm +GUo9FANL+mAnINmDiWn6VMaaGF5VKmTeBvaNSjutEDxlPZCIBIngMGGzrl0Bp3ve +fLK+ymVhAIau2o970ImtTR1ZmkGxvEeA3J5iw/mjgbIwga8wDwYDVR0TAQH/BAUw +AwEB/zAOBgNVHQ8BAf8EBAMCAQYwbQYIKwYBBQUHAQwEYTBfoV2gWzBZMFcwVRYJ +aW1hZ2UvZ2lmMCEwHzAHBgUrDgMCGgQUj+XTGoasjY5rw8+AatRIGCx7GS4wJRYj +aHR0cDovL2xvZ28udmVyaXNpZ24uY29tL3ZzbG9nby5naWYwHQYDVR0OBBYEFLMW +kf3upm7ktS5Jj4d4gYDs5bG1MAoGCCqGSM49BAMDA2gAMGUCMGYhDBgmYFo4e1ZC +4Kf8NoRRkSAsdk1DPcQdhCPQrNZ8NQbOzWm9kA3bbEhCHQ6qQgIxAJw9SDkjOVga +FRJZap7v1VmyHVIsmXHNxynfGyphe3HR3vPA5Q06Sqotp9iGKt0uEA== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIE0zCCA7ugAwIBAgIQGNrRniZ96LtKIVjNzGs7SjANBgkqhkiG9w0BAQUFADCB +yjELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL +ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNiBWZXJp +U2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxW +ZXJpU2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0 +aG9yaXR5IC0gRzUwHhcNMDYxMTA4MDAwMDAwWhcNMzYwNzE2MjM1OTU5WjCByjEL +MAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZW +ZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNiBWZXJpU2ln +biwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxWZXJp +U2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9y +aXR5IC0gRzUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvJAgIKXo1 +nmAMqudLO07cfLw8RRy7K+D+KQL5VwijZIUVJ/XxrcgxiV0i6CqqpkKzj/i5Vbex +t0uz/o9+B1fs70PbZmIVYc9gDaTY3vjgw2IIPVQT60nKWVSFJuUrjxuf6/WhkcIz +SdhDY2pSS9KP6HBRTdGJaXvHcPaz3BJ023tdS1bTlr8Vd6Gw9KIl8q8ckmcY5fQG +BO+QueQA5N06tRn/Arr0PO7gi+s3i+z016zy9vA9r911kTMZHRxAy3QkGSGT2RT+ +rCpSx4/VBEnkjWNHiDxpg8v+R70rfk/Fla4OndTRQ8Bnc+MUCH7lP59zuDMKz10/ +NIeWiu5T6CUVAgMBAAGjgbIwga8wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8E +BAMCAQYwbQYIKwYBBQUHAQwEYTBfoV2gWzBZMFcwVRYJaW1hZ2UvZ2lmMCEwHzAH +BgUrDgMCGgQUj+XTGoasjY5rw8+AatRIGCx7GS4wJRYjaHR0cDovL2xvZ28udmVy +aXNpZ24uY29tL3ZzbG9nby5naWYwHQYDVR0OBBYEFH/TZafC3ey78DAJ80M5+gKv +MzEzMA0GCSqGSIb3DQEBBQUAA4IBAQCTJEowX2LP2BqYLz3q3JktvXf2pXkiOOzE +p6B4Eq1iDkVwZMXnl2YtmAl+X6/WzChl8gGqCBpH3vn5fJJaCGkgDdk+bW48DW7Y +5gaRQBi5+MHt39tBquCWIMnNZBU4gcmU7qKEKQsTb47bDN0lAtukixlE0kF6BWlK +WE9gyn6CagsCqiUXObXbf+eEZSqVir2G3l6BFoMtEMze/aiCKm0oHw0LxOXnGiYZ +4fQRbxC1lfznQgUy286dUV4otp6F01vvpX1FQHKOtw5rDgb7MzVIcbidJ4vEZV8N +hnacRHr2lVz2XTIIM6RUthg/aFzyQkqFOFSDX9HoLPKsEdao7WNq +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEuTCCA6GgAwIBAgIQQBrEZCGzEyEDDrvkEhrFHTANBgkqhkiG9w0BAQsFADCB +vTELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL +ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwOCBWZXJp +U2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MTgwNgYDVQQDEy9W +ZXJpU2lnbiBVbml2ZXJzYWwgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAe +Fw0wODA0MDIwMDAwMDBaFw0zNzEyMDEyMzU5NTlaMIG9MQswCQYDVQQGEwJVUzEX +MBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZlcmlTaWduIFRydXN0 +IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAyMDA4IFZlcmlTaWduLCBJbmMuIC0gRm9y +IGF1dGhvcml6ZWQgdXNlIG9ubHkxODA2BgNVBAMTL1ZlcmlTaWduIFVuaXZlcnNh +bCBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEF +AAOCAQ8AMIIBCgKCAQEAx2E3XrEBNNti1xWb/1hajCMj1mCOkdeQmIN65lgZOIzF +9uVkhbSicfvtvbnazU0AtMgtc6XHaXGVHzk8skQHnOgO+k1KxCHfKWGPMiJhgsWH +H26MfF8WIFFE0XBPV+rjHOPMee5Y2A7Cs0WTwCznmhcrewA3ekEzeOEz4vMQGn+H +LL729fdC4uW/h2KJXwBL38Xd5HVEMkE6HnFuacsLdUYI0crSK5XQz/u5QGtkjFdN +/BMReYTtXlT2NJ8IAfMQJQYXStrxHXpma5hgZqTZ79IugvHw7wnqRMkVauIDbjPT +rJ9VAMf2CGqUuV/c4DPxhGD5WycRtPwW8rtWaoAljQIDAQABo4GyMIGvMA8GA1Ud +EwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMG0GCCsGAQUFBwEMBGEwX6FdoFsw +WTBXMFUWCWltYWdlL2dpZjAhMB8wBwYFKw4DAhoEFI/l0xqGrI2Oa8PPgGrUSBgs +exkuMCUWI2h0dHA6Ly9sb2dvLnZlcmlzaWduLmNvbS92c2xvZ28uZ2lmMB0GA1Ud +DgQWBBS2d/ppSEefUxLVwuoHMnYH0ZcHGTANBgkqhkiG9w0BAQsFAAOCAQEASvj4 +sAPmLGd75JR3Y8xuTPl9Dg3cyLk1uXBPY/ok+myDjEedO2Pzmvl2MpWRsXe8rJq+ +seQxIcaBlVZaDrHC1LGmWazxY8u4TB1ZkErvkBYoH1quEPuBUDgMbMzxPcP1Y+Oz +4yHJJDnp/RVmRvQbEdBNc6N9Rvk97ahfYtTxP/jgdFcrGJ2BtMQo2pSXpXDrrB2+ +BxHw1dvd5Yzw1TKwg+ZX4o+/vqGqvz0dtdQ46tewXDpPaj+PwGZsY6rp2aQW9IHR +lRQOfc2VNNnSj3BzgXucfr2YYdhFh5iQxeuGMMY1v/D/w1WIg0vvBZIGcfK4mJO3 +7M2CYfE45k+XmCpajQ== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICPDCCAaUCEHC65B0Q2Sk0tjjKewPMur8wDQYJKoZIhvcNAQECBQAwXzELMAkG +A1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFz +cyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTk2 +MDEyOTAwMDAwMFoXDTI4MDgwMTIzNTk1OVowXzELMAkGA1UEBhMCVVMxFzAVBgNV +BAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFzcyAzIFB1YmxpYyBQcmlt +YXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIGfMA0GCSqGSIb3DQEBAQUAA4GN +ADCBiQKBgQDJXFme8huKARS0EN8EQNvjV69qRUCPhAwL0TPZ2RHP7gJYHyX3KqhE +BarsAx94f56TuZoAqiN91qyFomNFx3InzPRMxnVx0jnvT0Lwdd8KkMaOIG+YD/is +I19wKTakyYbnsZogy1Olhec9vn2a/iRFM9x2Fe0PonFkTGUugWhFpwIDAQABMA0G +CSqGSIb3DQEBAgUAA4GBALtMEivPLCYATxQT3ab7/AoRhIzzKBxnki98tsX63/Do +lbwdj2wsqFHMc9ikwFPwTtYmwHYBV4GSXiHx0bH/59AhWM1pF+NEHJwZRDmJXNyc +AA9WjQKZ7aKQRUzkuxCkPfAyAw7xzvjoyVGM5mKf5p/AfbdynMk2OmufTqj/ZA1k +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICPDCCAaUCEDyRMcsf9tAbDpq40ES/Er4wDQYJKoZIhvcNAQEFBQAwXzELMAkG +A1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFz +cyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTk2 +MDEyOTAwMDAwMFoXDTI4MDgwMjIzNTk1OVowXzELMAkGA1UEBhMCVVMxFzAVBgNV +BAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFzcyAzIFB1YmxpYyBQcmlt +YXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIGfMA0GCSqGSIb3DQEBAQUAA4GN +ADCBiQKBgQDJXFme8huKARS0EN8EQNvjV69qRUCPhAwL0TPZ2RHP7gJYHyX3KqhE +BarsAx94f56TuZoAqiN91qyFomNFx3InzPRMxnVx0jnvT0Lwdd8KkMaOIG+YD/is +I19wKTakyYbnsZogy1Olhec9vn2a/iRFM9x2Fe0PonFkTGUugWhFpwIDAQABMA0G +CSqGSIb3DQEBBQUAA4GBABByUqkFFBkyCEHwxWsKzH4PIRnN5GfcX6kb5sroc50i +2JhucwNhkcV8sEVAbkSdjbCxlnRhLQ2pRdKkkirWmnWXbj9T/UWZYB2oK0z5XqcJ +2HUw19JlYD1n1khVdWk/kfVIC0dpImmClr7JyDiGSnoscxlIaU5rfGW/D/xwzoiQ +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDAjCCAmsCEH3Z/gfPqB63EHln+6eJNMYwDQYJKoZIhvcNAQEFBQAwgcExCzAJ +BgNVBAYTAlVTMRcwFQYDVQQKEw5WZXJpU2lnbiwgSW5jLjE8MDoGA1UECxMzQ2xh +c3MgMyBQdWJsaWMgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEcy +MTowOAYDVQQLEzEoYykgMTk5OCBWZXJpU2lnbiwgSW5jLiAtIEZvciBhdXRob3Jp +emVkIHVzZSBvbmx5MR8wHQYDVQQLExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMB4X +DTk4MDUxODAwMDAwMFoXDTI4MDgwMTIzNTk1OVowgcExCzAJBgNVBAYTAlVTMRcw +FQYDVQQKEw5WZXJpU2lnbiwgSW5jLjE8MDoGA1UECxMzQ2xhc3MgMyBQdWJsaWMg +UHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEcyMTowOAYDVQQLEzEo +YykgMTk5OCBWZXJpU2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5 +MR8wHQYDVQQLExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMIGfMA0GCSqGSIb3DQEB +AQUAA4GNADCBiQKBgQDMXtERXVxp0KvTuWpMmR9ZmDCOFoUgRm1HP9SFIIThbbP4 +pO0M8RcPO/mn+SXXwc+EY/J8Y8+iR/LGWzOOZEAEaMGAuWQcRXfH2G71lSk8UOg0 +13gfqLptQ5GVj0VXXn7F+8qkBOvqlzdUMG+7AUcyM83cV5tkaWH4mx0ciU9cZwID +AQABMA0GCSqGSIb3DQEBBQUAA4GBAFFNzb5cy5gZnBWyATl4Lk0PZ3BwmcYQWpSk +U01UbSuvDV1Ai2TT1+7eVmGSX6bEHRBhNtMsJzzoKQm5EWR0zLVznxxIqbxhAe7i +F6YM40AIOw7n60RzKprxaZLvcRTDOaxxp5EJb+RxBrO6WVcmeQD2+A2iMzAo1KpY +oJ2daZH9 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEGjCCAwICEQCbfgZJoz5iudXukEhxKe9XMA0GCSqGSIb3DQEBBQUAMIHKMQsw +CQYDVQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZl +cmlTaWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWdu +LCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlT +aWduIENsYXNzIDMgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3Jp +dHkgLSBHMzAeFw05OTEwMDEwMDAwMDBaFw0zNjA3MTYyMzU5NTlaMIHKMQswCQYD +VQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZlcmlT +aWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWduLCBJ +bmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlTaWdu +IENsYXNzIDMgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkg +LSBHMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMu6nFL8eB8aHm8b +N3O9+MlrlBIwT/A2R/XQkQr1F8ilYcEWQE37imGQ5XYgwREGfassbqb1EUGO+i2t +KmFZpGcmTNDovFJbcCAEWNF6yaRpvIMXZK0Fi7zQWM6NjPXr8EJJC52XJ2cybuGu +kxUccLwgTS8Y3pKI6GyFVxEa6X7jJhFUokWWVYPKMIno3Nij7SqAP395ZVc+FSBm +CC+Vk7+qRy+oRpfwEuL+wgorUeZ25rdGt+INpsyow0xZVYnm6FNcHOqd8GIWC6fJ +Xwzw3sJ2zq/3avL6QaaiMxTJ5Xpj055iN9WFZZ4O5lMkdBteHRJTW8cs54NJOxWu +imi5V5cCAwEAATANBgkqhkiG9w0BAQUFAAOCAQEAERSWwauSCPc/L8my/uRan2Te +2yFPhpk0djZX3dAVL8WtfxUfN2JzPtTnX84XA9s1+ivbrmAJXx5fj267Cz3qWhMe +DGBvtcC1IyIuBwvLqXTLR7sdwdela8wv0kL9Sd2nic9TutoAWii/gt/4uhMdUIaC +/Y4wjylGsB49Ndo4YhYYSq3mtlFs3q9i6wHQHiT+eo8SGhJouPtmmRQURVyu565p +F4ErWjfJXir0xuKhXFSbplQAz/DxwceYMBo7Nhbbo27q/a2ywtrvAkcTisDxszGt +TxzhT5yvDwyd93gN2PQ1VoDat20Xj50egWTh/sVFuq1ruQp6Tk9LhO5L8X3dEQ== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEGjCCAwICEQDsoKeLbnVqAc/EfMwvlF7XMA0GCSqGSIb3DQEBBQUAMIHKMQsw +CQYDVQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZl +cmlTaWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWdu +LCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlT +aWduIENsYXNzIDQgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3Jp +dHkgLSBHMzAeFw05OTEwMDEwMDAwMDBaFw0zNjA3MTYyMzU5NTlaMIHKMQswCQYD +VQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZlcmlT +aWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWduLCBJ +bmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlTaWdu +IENsYXNzIDQgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkg +LSBHMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAK3LpRFpxlmr8Y+1 +GQ9Wzsy1HyDkniYlS+BzZYlZ3tCD5PUPtbut8XzoIfzk6AzufEUiGXaStBO3IFsJ ++mGuqPKljYXCKtbeZjbSmwL0qJJgfJxptI8kHtCGUvYynEFYHiK9zUVilQhu0Gbd +U6LM8BDcVHOLBKFGMzNcF0C5nk3T875Vg+ixiY5afJqWIpA7iCXy0lOIAgwLePLm +NxdLMEYH5IBtptiWLugs+BGzOA1mppvqySNb247i8xOOGlktqgLw7KSHZtzBP/XY +ufTsgsbSPZUd5cBPhMnZo0QoBmrXRazwa2rvTl/4EYIeOGM0ZlDUPpNz+jDDZq3/ +ky2X7wMCAwEAATANBgkqhkiG9w0BAQUFAAOCAQEAj/ola09b5KROJ1WrIhVZPMq1 +CtRK26vdoV9TxaBXOcLORyu+OshWv8LZJxA6sQU8wHcxuzrTBXttmhwwjIDLk5Mq +g6sFUYICABFna/OIYUdfA5PVWw3g8dShMjWFsjrbsIKr0csKvE+MW8VLADsfKoKm +fjaF3H48ZwC15DtS4KjrXRX5xm3wrR0OhbepmnMUWluPQSjA1egtTaRezarZ7c7c +2NU8Qh0XwRJdRTjDOPP8hS6DRkiy1yBfkjaP53kPmF6Z6PDQpLv1U70qzlmwr25/ +bLvSHgCwIe34QWKCudiyxLtGUPMxxY8BqHTr9Xgn2uf3ZkPznoM+IKrDNWCRzg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDojCCAoqgAwIBAgIQE4Y1TR0/BvLB+WUF1ZAcYjANBgkqhkiG9w0BAQUFADBr +MQswCQYDVQQGEwJVUzENMAsGA1UEChMEVklTQTEvMC0GA1UECxMmVmlzYSBJbnRl +cm5hdGlvbmFsIFNlcnZpY2UgQXNzb2NpYXRpb24xHDAaBgNVBAMTE1Zpc2EgZUNv +bW1lcmNlIFJvb3QwHhcNMDIwNjI2MDIxODM2WhcNMjIwNjI0MDAxNjEyWjBrMQsw +CQYDVQQGEwJVUzENMAsGA1UEChMEVklTQTEvMC0GA1UECxMmVmlzYSBJbnRlcm5h +dGlvbmFsIFNlcnZpY2UgQXNzb2NpYXRpb24xHDAaBgNVBAMTE1Zpc2EgZUNvbW1l +cmNlIFJvb3QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvV95WHm6h +2mCxlCfLF9sHP4CFT8icttD0b0/Pmdjh28JIXDqsOTPHH2qLJj0rNfVIsZHBAk4E +lpF7sDPwsRROEW+1QK8bRaVK7362rPKgH1g/EkZgPI2h4H3PVz4zHvtH8aoVlwdV +ZqW1LS7YgFmypw23RuwhY/81q6UCzyr0TP579ZRdhE2o8mCP2w4lPJ9zcc+U30rq +299yOIzzlr3xF7zSujtFWsan9sYXiwGd/BmoKoMWuDpI/k4+oKsGGelT84ATB+0t +vz8KPFUgOSwsAGl0lUq8ILKpeeUYiZGo3BxN77t+Nwtd/jmliFKMAGzsGHxBvfaL +dXe6YJ2E5/4tAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQD +AgEGMB0GA1UdDgQWBBQVOIMPPyw/cDMezUb+B4wg4NfDtzANBgkqhkiG9w0BAQUF +AAOCAQEAX/FBfXxcCLkr4NWSR/pnXKUTwwMhmytMiUbPWU3J/qVAtmPN3XEolWcR +zCSs00Rsca4BIGsDoo8Ytyk6feUWYFN4PMCvFYP3j1IzJL1kk5fui/fbGKhtcbP3 +LBfQdCVp9/5rPJS+TUtBjE7ic9DjkCJzQ83z7+pzzkWKsKZJ/0x9nXGIxHYdkFsd +7v3M9+79YKWxehZx0RbQfBI8bGmX265fOZpwLwU8GUYEmSA20GBuYQa7FkKMcPcw +++DbZqMAAb3mLNqRX6BGi01qnD093QVG/na/oAo85ADmJ7f/hC3euiInlhBx6yLt +398znM/jra6O1I7mT1GvFpLgXPYHDw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEvTCCA6WgAwIBAgIBATANBgkqhkiG9w0BAQUFADCBhTELMAkGA1UEBhMCVVMx +IDAeBgNVBAoMF1dlbGxzIEZhcmdvIFdlbGxzU2VjdXJlMRwwGgYDVQQLDBNXZWxs +cyBGYXJnbyBCYW5rIE5BMTYwNAYDVQQDDC1XZWxsc1NlY3VyZSBQdWJsaWMgUm9v +dCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkwHhcNMDcxMjEzMTcwNzU0WhcNMjIxMjE0 +MDAwNzU0WjCBhTELMAkGA1UEBhMCVVMxIDAeBgNVBAoMF1dlbGxzIEZhcmdvIFdl +bGxzU2VjdXJlMRwwGgYDVQQLDBNXZWxscyBGYXJnbyBCYW5rIE5BMTYwNAYDVQQD +DC1XZWxsc1NlY3VyZSBQdWJsaWMgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkw +ggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDub7S9eeKPCCGeOARBJe+r +WxxTkqxtnt3CxC5FlAM1iGd0V+PfjLindo8796jE2yljDpFoNoqXjopxaAkH5OjU +Dk/41itMpBb570OYj7OeUt9tkTmPOL13i0Nj67eT/DBMHAGTthP796EfvyXhdDcs +HqRePGj4S78NuR4uNuip5Kf4D8uCdXw1LSLWwr8L87T8bJVhHlfXBIEyg1J55oNj +z7fLY4sR4r1e6/aN7ZVyKLSsEmLpSjPmgzKuBXWVvYSV2ypcm44uDLiBK0HmOFaf +SZtsdvqKXfcBeYF8wYNABf5x/Qw/zE5gCQ5lRxAvAcAFP4/4s0HvWkJ+We/Slwxl +AgMBAAGjggE0MIIBMDAPBgNVHRMBAf8EBTADAQH/MDkGA1UdHwQyMDAwLqAsoCqG +KGh0dHA6Ly9jcmwucGtpLndlbGxzZmFyZ28uY29tL3dzcHJjYS5jcmwwDgYDVR0P +AQH/BAQDAgHGMB0GA1UdDgQWBBQmlRkQ2eihl5H/3BnZtQQ+0nMKajCBsgYDVR0j +BIGqMIGngBQmlRkQ2eihl5H/3BnZtQQ+0nMKaqGBi6SBiDCBhTELMAkGA1UEBhMC +VVMxIDAeBgNVBAoMF1dlbGxzIEZhcmdvIFdlbGxzU2VjdXJlMRwwGgYDVQQLDBNX +ZWxscyBGYXJnbyBCYW5rIE5BMTYwNAYDVQQDDC1XZWxsc1NlY3VyZSBQdWJsaWMg +Um9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHmCAQEwDQYJKoZIhvcNAQEFBQADggEB +ALkVsUSRzCPIK0134/iaeycNzXK7mQDKfGYZUMbVmO2rvwNa5U3lHshPcZeG1eMd +/ZDJPHV3V3p9+N701NX3leZ0bh08rnyd2wIDBSxxSyU+B+NemvVmFymIGjifz6pB +A4SXa5M4esowRBskRDPQ5NHcKDj0E0M1NSljqHyita04pO2t/caaH/+Xc/77szWn +k4bGdpEA5qxRFsQnMlzbc9qlk1eOPm01JghZ1edE13YgY+esE2fDbbFwRnzVlhE9 +iW9dqKHrjQrawx0zbKPqZxmamX9LPYNRKh3KL4YMon4QLSvUFpULB6ouFJJJtylv +2G0xffX8oRAHh84vWdw+WNs= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFdjCCA16gAwIBAgIQXmjWEXGUY1BWAGjzPsnFkTANBgkqhkiG9w0BAQUFADBV +MQswCQYDVQQGEwJDTjEaMBgGA1UEChMRV29TaWduIENBIExpbWl0ZWQxKjAoBgNV +BAMTIUNlcnRpZmljYXRpb24gQXV0aG9yaXR5IG9mIFdvU2lnbjAeFw0wOTA4MDgw +MTAwMDFaFw0zOTA4MDgwMTAwMDFaMFUxCzAJBgNVBAYTAkNOMRowGAYDVQQKExFX +b1NpZ24gQ0EgTGltaXRlZDEqMCgGA1UEAxMhQ2VydGlmaWNhdGlvbiBBdXRob3Jp +dHkgb2YgV29TaWduMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAvcqN +rLiRFVaXe2tcesLea9mhsMMQI/qnobLMMfo+2aYpbxY94Gv4uEBf2zmoAHqLoE1U +fcIiePyOCbiohdfMlZdLdNiefvAA5A6JrkkoRBoQmTIPJYhTpA2zDxIIFgsDcScc +f+Hb0v1naMQFXQoOXXDX2JegvFNBmpGN9J42Znp+VsGQX+axaCA2pIwkLCxHC1l2 +ZjC1vt7tj/id07sBMOby8w7gLJKA84X5KIq0VC6a7fd2/BVoFutKbOsuEo/Uz/4M +x1wdC34FMr5esAkqQtXJTpCzWQ27en7N1QhatH/YHGkR+ScPewavVIMYe+HdVHpR +aG53/Ma/UkpmRqGyZxq7o093oL5d//xWC0Nyd5DKnvnyOfUNqfTq1+ezEC8wQjch +zDBwyYaYD8xYTYO7feUapTeNtqwylwA6Y3EkHp43xP901DfA4v6IRmAR3Qg/UDar +uHqklWJqbrDKaiFaafPz+x1wOZXzp26mgYmhiMU7ccqjUu6Du/2gd/Tkb+dC221K +mYo0SLwX3OSACCK28jHAPwQ+658geda4BmRkAjHXqc1S+4RFaQkAKtxVi8QGRkvA +Sh0JWzko/amrzgD5LkhLJuYwTKVYyrREgk/nkR4zw7CT/xH8gdLKH3Ep3XZPkiWv +HYG3Dy+MwwbMLyejSuQOmbp8HkUff6oZRZb9/D0CAwEAAaNCMEAwDgYDVR0PAQH/ +BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFOFmzw7R8bNLtwYgFP6H +EtX2/vs+MA0GCSqGSIb3DQEBBQUAA4ICAQCoy3JAsnbBfnv8rWTjMnvMPLZdRtP1 +LOJwXcgu2AZ9mNELIaCJWSQBnfmvCX0KI4I01fx8cpm5o9dU9OpScA7F9dY74ToJ +MuYhOZO9sxXqT2r09Ys/L3yNWC7F4TmgPsc9SnOeQHrAK2GpZ8nzJLmzbVUsWh2e +JXLOC62qx1ViC777Y7NhRCOjy+EaDveaBk3e1CNOIZZbOVtXHS9dCF4Jef98l7VN +g64N1uajeeAz0JmWAjCnPv/So0M/BVoG6kQC2nz4SNAzqfkHx5Xh9T71XXG68pWp +dIhhWeO/yloTunK0jF02h+mmxTwTv97QRCbut+wucPrXnbes5cVAWubXbHssw1ab +R80LzvobtCHXt2a49CUwi1wNuepnsvRtrtWhnk/Yn+knArAdBtaP4/tIEp9/EaEQ +PkxROpaw0RPxx9gmrjrKkcRpnd8BKWRRb2jaFOwIQZeQjdCygPLPwj2/kWjFgGce +xGATVdVhmVd8upUPYUk6ynW8yQqTP2cOEvIo4jEbwFcW3wh8GcF+Dx+FHgo2fFt+ +J7x6v+Db9NpSvd4MVHAxkUOVyLzwPt0JfjBkUO1/AaQzZ01oT74V77D2AhGiGxMl +OtzCWfHjXEa7ZywCRuoeSKbmW9m1vFGikpbbqsY3Iqb+zCB0oy2pLmvLwIIRIbWT +ee5Ehr7XHuQe+w== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFWDCCA0CgAwIBAgIQUHBrzdgT/BtOOzNy0hFIjTANBgkqhkiG9w0BAQsFADBG +MQswCQYDVQQGEwJDTjEaMBgGA1UEChMRV29TaWduIENBIExpbWl0ZWQxGzAZBgNV +BAMMEkNBIOayg+mAmuagueivgeS5pjAeFw0wOTA4MDgwMTAwMDFaFw0zOTA4MDgw +MTAwMDFaMEYxCzAJBgNVBAYTAkNOMRowGAYDVQQKExFXb1NpZ24gQ0EgTGltaXRl +ZDEbMBkGA1UEAwwSQ0Eg5rKD6YCa5qC56K+B5LmmMIICIjANBgkqhkiG9w0BAQEF +AAOCAg8AMIICCgKCAgEA0EkhHiX8h8EqwqzbdoYGTufQdDTc7WU1/FDWiD+k8H/r +D195L4mx/bxjWDeTmzj4t1up+thxx7S8gJeNbEvxUNUqKaqoGXqW5pWOdO2XCld1 +9AXbbQs5uQF/qvbW2mzmBeCkTVL829B0txGMe41P/4eDrv8FAxNXUDf+jJZSEExf +v5RxadmWPgxDT74wwJ85dE8GRV2j1lY5aAfMh09Qd5Nx2UQIsYo06Yms25tO4dnk +UkWMLhQfkWsZHWgpLFbE4h4TV2TwYeO5Ed+w4VegG63XX9Gv2ystP9Bojg/qnw+L +NVgbExz03jWhCl3W6t8Sb8D7aQdGctyB9gQjF+BNdeFyb7Ao65vh4YOhn0pdr8yb ++gIgthhid5E7o9Vlrdx8kHccREGkSovrlXLp9glk3Kgtn3R46MGiCWOc76DbT52V +qyBPt7D3h1ymoOQ3OMdc4zUPLK2jgKLsLl3Az+2LBcLmc272idX10kaO6m1jGx6K +yX2m+Jzr5dVjhU1zZmkR/sgO9MHHZklTfuQZa/HpelmjbX7FF+Ynxu8b22/8DU0G +AbQOXDBGVWCvOGU6yke6rCzMRh+yRpY/8+0mBe53oWprfi1tWFxK1I5nuPHa1UaK +J/kR8slC/k7e3x9cxKSGhxYzoacXGKUN5AXlK8IrC6KVkLn9YDxOiT7nnO4fuwEC +AwEAAaNCMEAwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0O +BBYEFOBNv9ybQV0T6GTwp+kVpOGBwboxMA0GCSqGSIb3DQEBCwUAA4ICAQBqinA4 +WbbaixjIvirTthnVZil6Xc1bL3McJk6jfW+rtylNpumlEYOnOXOvEESS5iVdT2H6 +yAa+Tkvv/vMx/sZ8cApBWNromUuWyXi8mHwCKe0JgOYKOoICKuLJL8hWGSbueBwj +/feTZU7n85iYr83d2Z5AiDEoOqsuC7CsDCT6eiaY8xJhEPRdF/d+4niXVOKM6Cm6 +jBAyvd0zaziGfjk9DgNyp115j0WKWa5bIW4xRtVZjc8VX90xJc/bYNaBRHIpAlf2 +ltTW/+op2znFuCyKGo3Oy+dCMYYFaA6eFN0AkLppRQjbbpCBhqcqBT/mhDn4t/lX +X0ykeVoQDF7Va/81XwVRHmyjdanPUIPTfPRm94KNPQx96N97qA4bLJyuQHCH2u2n +FoJavjVsIE4iYdm8UXrNemHcSxH5/mc0zy4EZmFcV5cjjPOGG0jfKq+nwf/Yjj4D +u9gqsPoUJbJRa4ZDhS4HIxaAjUz7tGM7zMN07RujHv41D198HRaG9Q7DlfEvr10l +O1Hm13ZBONFLAzkopR6RctR9q5czxNM+4Gm2KHmgCY0c0f9BckgG/Jou5yD5m6Le +ie2uPAmvylezkolwQOQvT8Jwg0DXJCxr5wkf09XHwQj02w47HAcLQxGEIYbpgNR1 +2KvxAmLBsX5VYc8T1yaw15zLKYs4SgsOkI26oQ== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEMDCCAxigAwIBAgIQUJRs7Bjq1ZxN1ZfvdY+grTANBgkqhkiG9w0BAQUFADCB +gjELMAkGA1UEBhMCVVMxHjAcBgNVBAsTFXd3dy54cmFtcHNlY3VyaXR5LmNvbTEk +MCIGA1UEChMbWFJhbXAgU2VjdXJpdHkgU2VydmljZXMgSW5jMS0wKwYDVQQDEyRY +UmFtcCBHbG9iYWwgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQxMTAxMTcx +NDA0WhcNMzUwMTAxMDUzNzE5WjCBgjELMAkGA1UEBhMCVVMxHjAcBgNVBAsTFXd3 +dy54cmFtcHNlY3VyaXR5LmNvbTEkMCIGA1UEChMbWFJhbXAgU2VjdXJpdHkgU2Vy +dmljZXMgSW5jMS0wKwYDVQQDEyRYUmFtcCBHbG9iYWwgQ2VydGlmaWNhdGlvbiBB +dXRob3JpdHkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCYJB69FbS6 +38eMpSe2OAtp87ZOqCwuIR1cRN8hXX4jdP5efrRKt6atH67gBhbim1vZZ3RrXYCP +KZ2GG9mcDZhtdhAoWORlsH9KmHmf4MMxfoArtYzAQDsRhtDLooY2YKTVMIJt2W7Q +DxIEM5dfT2Fa8OT5kavnHTu86M/0ay00fOJIYRyO82FEzG+gSqmUsE3a56k0enI4 +qEHMPJQRfevIpoy3hsvKMzvZPTeL+3o+hiznc9cKV6xkmxnr9A8ECIqsAxcZZPRa +JSKNNCyy9mgdEm3Tih4U2sSPpuIjhdV6Db1q4Ons7Be7QhtnqiXtRYMh/MHJfNVi +PvryxS3T/dRlAgMBAAGjgZ8wgZwwEwYJKwYBBAGCNxQCBAYeBABDAEEwCwYDVR0P +BAQDAgGGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFMZPoj0GY4QJnM5i5ASs +jVy16bYbMDYGA1UdHwQvMC0wK6ApoCeGJWh0dHA6Ly9jcmwueHJhbXBzZWN1cml0 +eS5jb20vWEdDQS5jcmwwEAYJKwYBBAGCNxUBBAMCAQEwDQYJKoZIhvcNAQEFBQAD +ggEBAJEVOQMBG2f7Shz5CmBbodpNl2L5JFMn14JkTpAuw0kbK5rc/Kh4ZzXxHfAR +vbdI4xD2Dd8/0sm2qlWkSLoC295ZLhVbO50WfUfXN+pfTXYSNrsf16GBBEYgoyxt +qZ4Bfj8pzgCT3/3JknOJiWSe5yvkHJEs0rnOfc5vMZnT5r7SHpDwCRR5XCOrTdLa +IR9NmXmd4c8nnxCbHIgNsIpkQTG4DmyQJKSbXHGPurt+HBvbaoAPIbzp26a3QPSy +i6mx5O+aGtA9aZnuqCij4Tyz8LIRnM98QObd50N9otg6tamN8jSZxNQQ4Qb9CYQQ +O+7ETPTsJ3xCwnR8gooJybQDJbw= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDODCCAiCgAwIBAgIGIAYFFnACMA0GCSqGSIb3DQEBBQUAMDsxCzAJBgNVBAYT +AlJPMREwDwYDVQQKEwhjZXJ0U0lHTjEZMBcGA1UECxMQY2VydFNJR04gUk9PVCBD +QTAeFw0wNjA3MDQxNzIwMDRaFw0zMTA3MDQxNzIwMDRaMDsxCzAJBgNVBAYTAlJP +MREwDwYDVQQKEwhjZXJ0U0lHTjEZMBcGA1UECxMQY2VydFNJR04gUk9PVCBDQTCC +ASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALczuX7IJUqOtdu0KBuqV5Do +0SLTZLrTk+jUrIZhQGpgV2hUhE28alQCBf/fm5oqrl0Hj0rDKH/v+yv6efHHrfAQ +UySQi2bJqIirr1qjAOm+ukbuW3N7LBeCgV5iLKECZbO9xSsAfsT8AzNXDe3i+s5d +RdY4zTW2ssHQnIFKquSyAVwdj1+ZxLGt24gh65AIgoDzMKND5pCCrlUoSe1b16kQ +OA7+j0xbm0bqQfWwCHTD0IgztnzXdN/chNFDDnU5oSVAKOp4yw4sLjmdjItuFhwv +JoIQ4uNllAoEwF73XVv4EOLQunpL+943AAAaWyjj0pxzPjKHmKHJUS/X3qwzs08C +AwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAcYwHQYDVR0O +BBYEFOCMm9slSbPxfIbWskKHC9BroNnkMA0GCSqGSIb3DQEBBQUAA4IBAQA+0hyJ +LjX8+HXd5n9liPRyTMks1zJO890ZeUe9jjtbkw9QSSQTaxQGcu8J06Gh40CEyecY +MnQ8SG4Pn0vU9x7Tk4ZkVJdjclDVVc/6IJMCopvDI5NOFlV2oHB5bc0hH88vLbwZ +44gx+FkagQnIl6Z0x2DEW8xXjrJ1/RsCCdtZb3KTafcxQdaIOL+Hsr0Wefmq5L6I +Jd1hJyMctTEHBDa0GpC9oHRxUIltvBTjD4au8as+x6AJzKNI0eDbZOeStc+vckNw +i/nDhDwTqn6Sm1dTk/pwwpEOMfmbZ13pljheX7NzTogVZ96edhBiIL5VaZVDADlN +9u6wWk5JRFRYX0KD +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFsDCCA5igAwIBAgIQFci9ZUdcr7iXAF7kBtK8nTANBgkqhkiG9w0BAQUFADBe +MQswCQYDVQQGEwJUVzEjMCEGA1UECgwaQ2h1bmdod2EgVGVsZWNvbSBDby4sIEx0 +ZC4xKjAoBgNVBAsMIWVQS0kgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAe +Fw0wNDEyMjAwMjMxMjdaFw0zNDEyMjAwMjMxMjdaMF4xCzAJBgNVBAYTAlRXMSMw +IQYDVQQKDBpDaHVuZ2h3YSBUZWxlY29tIENvLiwgTHRkLjEqMCgGA1UECwwhZVBL +SSBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIICIjANBgkqhkiG9w0BAQEF +AAOCAg8AMIICCgKCAgEA4SUP7o3biDN1Z82tH306Tm2d0y8U82N0ywEhajfqhFAH +SyZbCUNsIZ5qyNUD9WBpj8zwIuQf5/dqIjG3LBXy4P4AakP/h2XGtRrBp0xtInAh +ijHyl3SJCRImHJ7K2RKilTza6We/CKBk49ZCt0Xvl/T29de1ShUCWH2YWEtgvM3X +DZoTM1PRYfl61dd4s5oz9wCGzh1NlDivqOx4UXCKXBCDUSH3ET00hl7lSM2XgYI1 +TBnsZfZrxQWh7kcT1rMhJ5QQCtkkO7q+RBNGMD+XPNjX12ruOzjjK9SXDrkb5wdJ +fzcq+Xd4z1TtW0ado4AOkUPB1ltfFLqfpo0kR0BZv3I4sjZsN/+Z0V0OWQqraffA +sgRFelQArr5T9rXn4fg8ozHSqf4hUmTFpmfwdQcGlBSBVcYn5AGPF8Fqcde+S/uU +WH1+ETOxQvdibBjWzwloPn9s9h6PYq2lY9sJpx8iQkEeb5mKPtf5P0B6ebClAZLS +nT0IFaUQAS2zMnaolQ2zepr7BxB4EW/hj8e6DyUadCrlHJhBmd8hh+iVBmoKs2pH +dmX2Os+PYhcZewoozRrSgx4hxyy/vv9haLdnG7t4TY3OZ+XkwY63I2binZB1NJip +NiuKmpS5nezMirH4JYlcWrYvjB9teSSnUmjDhDXiZo1jDiVN1Rmy5nk3pyKdVDEC +AwEAAaNqMGgwHQYDVR0OBBYEFB4M97Zn8uGSJglFwFU5Lnc/QkqiMAwGA1UdEwQF +MAMBAf8wOQYEZyoHAAQxMC8wLQIBADAJBgUrDgMCGgUAMAcGBWcqAwAABBRFsMLH +ClZ87lt4DJX5GFPBphzYEDANBgkqhkiG9w0BAQUFAAOCAgEACbODU1kBPpVJufGB +uvl2ICO1J2B01GqZNF5sAFPZn/KmsSQHRGoqxqWOeBLoR9lYGxMqXnmbnwoqZ6Yl +PwZpVnPDimZI+ymBV3QGypzqKOg4ZyYr8dW1P2WT+DZdjo2NQCCHGervJ8A9tDkP +JXtoUHRVnAxZfVo9QZQlUgjgRywVMRnVvwdVxrsStZf0X4OFunHB2WyBEXYKCrC/ +gpf36j36+uwtqSiUO1bd0lEursC9CBWMd1I0ltabrNMdjmEPNXubrjlpC2JgQCA2 +j6/7Nu4tCEoduL+bXPjqpRugc6bY+G7gMwRfaKonh+3ZwZCc7b3jajWvY9+rGNm6 +5ulK6lCKD2GTHuItGeIwlDWSXQ62B68ZgI9HkFFLLk3dheLSClIKF5r8GrBQAuUB +o2M3IUxExJtRmREOc5wGj1QupyheRDmHVi03vYVElOEMSyycw5KFNGHLD7ibSkNS +/jQ6fbjpKdx2qcgw+BRxgMYeNkh0IkFch4LoGHGLQYlE535YW6i4jRPpp2zDR+2z +Gp1iro2C6pSe3VkQw63d4k3jMdXH7OjysP6SHhYKGvzZ8/gntsm+HbRsZJB/9OTE +W9c3rkIO3aQab3yIVMUWbuF6aC74Or8NpDyJO3inTmODBCEIZ43ygknQW/2xzQ+D +hNQ+IIX3Sj0rnP0qCglN6oH4EZw= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEIDCCAwigAwIBAgIQNE7VVyDV7exJ9C/ON9srbTANBgkqhkiG9w0BAQUFADCB +qTELMAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5jLjEoMCYGA1UECxMf +Q2VydGlmaWNhdGlvbiBTZXJ2aWNlcyBEaXZpc2lvbjE4MDYGA1UECxMvKGMpIDIw +MDYgdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxHzAdBgNV +BAMTFnRoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EwHhcNMDYxMTE3MDAwMDAwWhcNMzYw +NzE2MjM1OTU5WjCBqTELMAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5j +LjEoMCYGA1UECxMfQ2VydGlmaWNhdGlvbiBTZXJ2aWNlcyBEaXZpc2lvbjE4MDYG +A1UECxMvKGMpIDIwMDYgdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNl +IG9ubHkxHzAdBgNVBAMTFnRoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EwggEiMA0GCSqG +SIb3DQEBAQUAA4IBDwAwggEKAoIBAQCsoPD7gFnUnMekz52hWXMJEEUMDSxuaPFs +W0hoSVk3/AszGcJ3f8wQLZU0HObrTQmnHNK4yZc2AreJ1CRfBsDMRJSUjQJib+ta +3RGNKJpchJAQeg29dGYvajig4tVUROsdB58Hum/u6f1OCyn1PoSgAfGcq/gcfomk +6KHYcWUNo1F77rzSImANuVud37r8UVsLr5iy6S7pBOhih94ryNdOwUxkHt3Ph1i6 +Sk/KaAcdHJ1KxtUvkcx8cXIcxcBn6zL9yZJclNqFwJu/U30rCfSMnZEfl2pSy94J +NqR32HuHUETVPm4pafs5SSYeCaWAe0At6+gnhcn+Yf1+5nyXHdWdAgMBAAGjQjBA +MA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBR7W0XP +r87Lev0xkhpqtvNG61dIUDANBgkqhkiG9w0BAQUFAAOCAQEAeRHAS7ORtvzw6WfU +DW5FvlXok9LOAz/t2iWwHVfLHjp2oEzsUHboZHIMpKnxuIvW1oeEuzLlQRHAd9mz +YJ3rG9XRbkREqaYB7FViHXe4XI5ISXycO1cRrK1zN44veFyQaEfZYGDm/Ac9IiAX +xPcW6cTYcvnIc3zfFi8VqT79aie2oetaupgf1eNNZAqdE8hhuvU5HIe6uL17In/2 +/qxAeeWsEG89jxt5dovEN7MhGITlNgDrYyCZuen+MwS7QcjBAvlEYyCegc5C09Y/ +LHbTY5xZ3Y+m4Q6gLkH3LpVHz7z9M/P2C2F+fpErgUfCJzDupxBdN49cOSvkBPB7 +jVaMaA== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICiDCCAg2gAwIBAgIQNfwmXNmET8k9Jj1Xm67XVjAKBggqhkjOPQQDAzCBhDEL +MAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5jLjE4MDYGA1UECxMvKGMp +IDIwMDcgdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxJDAi +BgNVBAMTG3RoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EgLSBHMjAeFw0wNzExMDUwMDAw +MDBaFw0zODAxMTgyMzU5NTlaMIGEMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMdGhh +d3RlLCBJbmMuMTgwNgYDVQQLEy8oYykgMjAwNyB0aGF3dGUsIEluYy4gLSBGb3Ig +YXV0aG9yaXplZCB1c2Ugb25seTEkMCIGA1UEAxMbdGhhd3RlIFByaW1hcnkgUm9v +dCBDQSAtIEcyMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEotWcgnuVnfFSeIf+iha/ +BebfowJPDQfGAFG6DAJSLSKkQjnE/o/qycG+1E3/n3qe4rF8mq2nhglzh9HnmuN6 +papu+7qzcMBniKI11KOasf2twu8x+qi58/sIxpHR+ymVo0IwQDAPBgNVHRMBAf8E +BTADAQH/MA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUmtgAMADna3+FGO6Lts6K +DPgR4bswCgYIKoZIzj0EAwMDaQAwZgIxAN344FdHW6fmCsO99YCKlzUNG4k8VIZ3 +KMqh9HneteY4sPBlcIx/AlTCv//YoT7ZzwIxAMSNlPzcU9LcnXgWHxUzI1NS41ox +XZ3Krr0TKUQNJ1uo52icEvdYPy5yAlejj6EULg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEKjCCAxKgAwIBAgIQYAGXt0an6rS0mtZLL/eQ+zANBgkqhkiG9w0BAQsFADCB +rjELMAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5jLjEoMCYGA1UECxMf +Q2VydGlmaWNhdGlvbiBTZXJ2aWNlcyBEaXZpc2lvbjE4MDYGA1UECxMvKGMpIDIw +MDggdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxJDAiBgNV +BAMTG3RoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EgLSBHMzAeFw0wODA0MDIwMDAwMDBa +Fw0zNzEyMDEyMzU5NTlaMIGuMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMdGhhd3Rl +LCBJbmMuMSgwJgYDVQQLEx9DZXJ0aWZpY2F0aW9uIFNlcnZpY2VzIERpdmlzaW9u +MTgwNgYDVQQLEy8oYykgMjAwOCB0aGF3dGUsIEluYy4gLSBGb3IgYXV0aG9yaXpl +ZCB1c2Ugb25seTEkMCIGA1UEAxMbdGhhd3RlIFByaW1hcnkgUm9vdCBDQSAtIEcz +MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsr8nLPvb2FvdeHsbnndm +gcs+vHyu86YnmjSjaDFxODNi5PNxZnmxqWWjpYvVj2AtP0LMqmsywCPLLEHd5N/8 +YZzic7IilRFDGF/Eth9XbAoFWCLINkw6fKXRz4aviKdEAhN0cXMKQlkC+BsUa0Lf +b1+6a4KinVvnSr0eAXLbS3ToO39/fR8EtCab4LRarEc9VbjXsCZSKAExQGbY2SS9 +9irY7CFJXJv2eul/VTV+lmuNk5Mny5K76qxAwJ/C+IDPXfRa3M50hqY+bAtTyr2S +zhkGcuYMXDhpxwTWvGzOW/b3aJzcJRVIiKHpqfiYnODz1TEoYRFsZ5aNOZnLwkUk +OQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjAdBgNV +HQ4EFgQUrWyqlGCc7eT/+j4KdCtjA/e2Wb8wDQYJKoZIhvcNAQELBQADggEBABpA +2JVlrAmSicY59BDlqQ5mU1143vokkbvnRFHfxhY0Cu9qRFHqKweKA3rD6z8KLFIW +oCtDuSWQP3CpMyVtRRooOyfPqsMpQhvfO0zAMzRbQYi/aytlryjvsvXDqmbOe1bu +t8jLZ8HJnBoYuMTDSQPxYA5QzUbF83d597YV4Djbxy8ooAw/dyZ02SUS2jHaGh7c +KUGRIjxpp7sC8rZcJwOJ9Abqm+RyguOhCcHpABnTPtRwa7pxpqpYrvS76Wy274fM +m7v/OeZWYdMKp8RcTGB7BXcmer/YB1IsYvdwY9k5vG8cwnncdimvzsUsZAReiDZu +MdRAGmI0Nj81Aa6sY6A= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIHPTCCBSWgAwIBAgIBADANBgkqhkiG9w0BAQQFADB5MRAwDgYDVQQKEwdSb290 +IENBMR4wHAYDVQQLExVodHRwOi8vd3d3LmNhY2VydC5vcmcxIjAgBgNVBAMTGUNB +IENlcnQgU2lnbmluZyBBdXRob3JpdHkxITAfBgkqhkiG9w0BCQEWEnN1cHBvcnRA +Y2FjZXJ0Lm9yZzAeFw0wMzAzMzAxMjI5NDlaFw0zMzAzMjkxMjI5NDlaMHkxEDAO +BgNVBAoTB1Jvb3QgQ0ExHjAcBgNVBAsTFWh0dHA6Ly93d3cuY2FjZXJ0Lm9yZzEi +MCAGA1UEAxMZQ0EgQ2VydCBTaWduaW5nIEF1dGhvcml0eTEhMB8GCSqGSIb3DQEJ +ARYSc3VwcG9ydEBjYWNlcnQub3JnMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIIC +CgKCAgEAziLA4kZ97DYoB1CW8qAzQIxL8TtmPzHlawI229Z89vGIj053NgVBlfkJ +8BLPRoZzYLdufujAWGSuzbCtRRcMY/pnCujW0r8+55jE8Ez64AO7NV1sId6eINm6 +zWYyN3L69wj1x81YyY7nDl7qPv4coRQKFWyGhFtkZip6qUtTefWIonvuLwphK42y +fk1WpRPs6tqSnqxEQR5YYGUFZvjARL3LlPdCfgv3ZWiYUQXw8wWRBB0bF4LsyFe7 +w2t6iPGwcswlWyCR7BYCEo8y6RcYSNDHBS4CMEK4JZwFaz+qOqfrU0j36NK2B5jc +G8Y0f3/JHIJ6BVgrCFvzOKKrF11myZjXnhCLotLddJr3cQxyYN/Nb5gznZY0dj4k +epKwDpUeb+agRThHqtdB7Uq3EvbXG4OKDy7YCbZZ16oE/9KTfWgu3YtLq1i6L43q +laegw1SJpfvbi1EinbLDvhG+LJGGi5Z4rSDTii8aP8bQUWWHIbEZAWV/RRyH9XzQ +QUxPKZgh/TMfdQwEUfoZd9vUFBzugcMd9Zi3aQaRIt0AUMyBMawSB3s42mhb5ivU +fslfrejrckzzAeVLIL+aplfKkQABi6F1ITe1Yw1nPkZPcCBnzsXWWdsC4PDSy826 +YreQQejdIOQpvGQpQsgi3Hia/0PsmBsJUUtaWsJx8cTLc6nloQsCAwEAAaOCAc4w +ggHKMB0GA1UdDgQWBBQWtTIb1Mfz4OaO873SsDrusjkY0TCBowYDVR0jBIGbMIGY +gBQWtTIb1Mfz4OaO873SsDrusjkY0aF9pHsweTEQMA4GA1UEChMHUm9vdCBDQTEe +MBwGA1UECxMVaHR0cDovL3d3dy5jYWNlcnQub3JnMSIwIAYDVQQDExlDQSBDZXJ0 +IFNpZ25pbmcgQXV0aG9yaXR5MSEwHwYJKoZIhvcNAQkBFhJzdXBwb3J0QGNhY2Vy +dC5vcmeCAQAwDwYDVR0TAQH/BAUwAwEB/zAyBgNVHR8EKzApMCegJaAjhiFodHRw +czovL3d3dy5jYWNlcnQub3JnL3Jldm9rZS5jcmwwMAYJYIZIAYb4QgEEBCMWIWh0 +dHBzOi8vd3d3LmNhY2VydC5vcmcvcmV2b2tlLmNybDA0BglghkgBhvhCAQgEJxYl +aHR0cDovL3d3dy5jYWNlcnQub3JnL2luZGV4LnBocD9pZD0xMDBWBglghkgBhvhC +AQ0ESRZHVG8gZ2V0IHlvdXIgb3duIGNlcnRpZmljYXRlIGZvciBGUkVFIGhlYWQg +b3ZlciB0byBodHRwOi8vd3d3LmNhY2VydC5vcmcwDQYJKoZIhvcNAQEEBQADggIB +ACjH7pyCArpcgBLKNQodgW+JapnM8mgPf6fhjViVPr3yBsOQWqy1YPaZQwGjiHCc +nWKdpIevZ1gNMDY75q1I08t0AoZxPuIrA2jxNGJARjtT6ij0rPtmlVOKTV39O9lg +18p5aTuxZZKmxoGCXJzN600BiqXfEVWqFcofN8CCmHBh22p8lqOOLlQ+TyGpkO/c +gr/c6EWtTZBzCDyUZbAEmXZ/4rzCahWqlwQ3JNgelE5tDlG+1sSPypZt90Pf6DBl +Jzt7u0NDY8RD97LsaMzhGY4i+5jhe1o+ATc7iwiwovOVThrLm82asduycPAtStvY +sONvRUgzEv/+PDIqVPfE94rwiCPCR/5kenHA0R6mY7AHfqQv0wGP3J8rtsYIqQ+T +SCX8Ev2fQtzzxD72V7DX3WnRBnc0CkvSyqD/HMaMyRa+xMwyN2hzXwj7UfdJUzYF +CpUCTPJ5GhD22Dp1nPMd8aINcGeGG7MW9S/lpOt5hvk9C8JzC6WZrG/8Z7jlLwum +GCSNe9FINSkYQKyTYOGWhlC0elnYjyELn8+CkcY7v2vcB5G5l1YjqrZslMZIBjzk +zk6q5PYvCdxTby78dOs6Y5nCpqyJvKeyRKANihDjbPIky/qbn3BHLt4Ui9SyIAmW +omTxJBzcoTWcFbLUvFUufQb1nA5V9FrWk9p2rSVzTMVD +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIHWTCCBUGgAwIBAgIDCkGKMA0GCSqGSIb3DQEBCwUAMHkxEDAOBgNVBAoTB1Jv +b3QgQ0ExHjAcBgNVBAsTFWh0dHA6Ly93d3cuY2FjZXJ0Lm9yZzEiMCAGA1UEAxMZ +Q0EgQ2VydCBTaWduaW5nIEF1dGhvcml0eTEhMB8GCSqGSIb3DQEJARYSc3VwcG9y +dEBjYWNlcnQub3JnMB4XDTExMDUyMzE3NDgwMloXDTIxMDUyMDE3NDgwMlowVDEU +MBIGA1UEChMLQ0FjZXJ0IEluYy4xHjAcBgNVBAsTFWh0dHA6Ly93d3cuQ0FjZXJ0 +Lm9yZzEcMBoGA1UEAxMTQ0FjZXJ0IENsYXNzIDMgUm9vdDCCAiIwDQYJKoZIhvcN +AQEBBQADggIPADCCAgoCggIBAKtJNRFIfNImflOUz0Op3SjXQiqL84d4GVh8D57a +iX3h++tykA10oZZkq5+gJJlz2uJVdscXe/UErEa4w75/ZI0QbCTzYZzA8pD6Ueb1 +aQFjww9W4kpCz+JEjCUoqMV5CX1GuYrz6fM0KQhF5Byfy5QEHIGoFLOYZcRD7E6C +jQnRvapbjZLQ7N6QxX8KwuPr5jFaXnQ+lzNZ6MMDPWAzv/fRb0fEze5ig1JuLgia +pNkVGJGmhZJHsK5I6223IeyFGmhyNav/8BBdwPSUp2rVO5J+TJAFfpPBLIukjmJ0 +FXFuC3ED6q8VOJrU0gVyb4z5K+taciX5OUbjchs+BMNkJyIQKopPWKcDrb60LhPt +XapI19V91Cp7XPpGBFDkzA5CW4zt2/LP/JaT4NsRNlRiNDiPDGCbO5dWOK3z0luL +oFvqTpa4fNfVoIZwQNORKbeiPK31jLvPGpKK5DR7wNhsX+kKwsOnIJpa3yxdUly6 +R9Wb7yQocDggL9V/KcCyQQNokszgnMyXS0XvOhAKq3A6mJVwrTWx6oUrpByAITGp +rmB6gCZIALgBwJNjVSKRPFbnr9s6JfOPMVTqJouBWfmh0VMRxXudA/Z0EeBtsSw/ +LIaRmXGapneLNGDRFLQsrJ2vjBDTn8Rq+G8T/HNZ92ZCdB6K4/jc0m+YnMtHmJVA +BfvpAgMBAAGjggINMIICCTAdBgNVHQ4EFgQUdahxYEyIE/B42Yl3tW3Fid+8sXow +gaMGA1UdIwSBmzCBmIAUFrUyG9TH8+DmjvO90rA67rI5GNGhfaR7MHkxEDAOBgNV +BAoTB1Jvb3QgQ0ExHjAcBgNVBAsTFWh0dHA6Ly93d3cuY2FjZXJ0Lm9yZzEiMCAG +A1UEAxMZQ0EgQ2VydCBTaWduaW5nIEF1dGhvcml0eTEhMB8GCSqGSIb3DQEJARYS +c3VwcG9ydEBjYWNlcnQub3JnggEAMA8GA1UdEwEB/wQFMAMBAf8wXQYIKwYBBQUH +AQEEUTBPMCMGCCsGAQUFBzABhhdodHRwOi8vb2NzcC5DQWNlcnQub3JnLzAoBggr +BgEFBQcwAoYcaHR0cDovL3d3dy5DQWNlcnQub3JnL2NhLmNydDBKBgNVHSAEQzBB +MD8GCCsGAQQBgZBKMDMwMQYIKwYBBQUHAgEWJWh0dHA6Ly93d3cuQ0FjZXJ0Lm9y +Zy9pbmRleC5waHA/aWQ9MTAwNAYJYIZIAYb4QgEIBCcWJWh0dHA6Ly93d3cuQ0Fj +ZXJ0Lm9yZy9pbmRleC5waHA/aWQ9MTAwUAYJYIZIAYb4QgENBEMWQVRvIGdldCB5 +b3VyIG93biBjZXJ0aWZpY2F0ZSBmb3IgRlJFRSwgZ28gdG8gaHR0cDovL3d3dy5D +QWNlcnQub3JnMA0GCSqGSIb3DQEBCwUAA4ICAQApKIWuRKm5r6R5E/CooyuXYPNc +7uMvwfbiZqARrjY3OnYVBFPqQvX56sAV2KaC2eRhrnILKVyQQ+hBsuF32wITRHhH +Va9Y/MyY9kW50SD42CEH/m2qc9SzxgfpCYXMO/K2viwcJdVxjDm1Luq+GIG6sJO4 +D+Pm1yaMMVpyA4RS5qb1MyJFCsgLDYq4Nm+QCaGrvdfVTi5xotSu+qdUK+s1jVq3 +VIgv7nSf7UgWyg1I0JTTrKSi9iTfkuO960NAkW4cGI5WtIIS86mTn9S8nK2cde5a +lxuV53QtHA+wLJef+6kzOXrnAzqSjiL2jA3k2X4Ndhj3AfnvlpaiVXPAPHG0HRpW +Q7fDCo1y/OIQCQtBzoyUoPkD/XFzS4pXM+WOdH4VAQDmzEoc53+VGS3FpQyLu7Xt +hbNc09+4ufLKxw0BFKxwWMWMjTPUnWajGlCVI/xI4AZDEtnNp4Y5LzZyo4AQ5OHz +0ctbGsDkgJp8E3MGT9ujayQKurMcvEp4u+XjdTilSKeiHq921F73OIZWWonO1sOn +ebJSoMbxhbQljPI/lrMQ2Y1sVzufb4Y6GIIiNsiwkTjbKqGTqoQ/9SdlrnPVyNXT +d+pLncdBu8fA46A/5H2kjXPmEkvfoXNzczqA6NXLji/L6hOn1kGLrPo8idck9U60 +4GGSt/M3mMS+lqO3ig== +-----END CERTIFICATE----- diff --git a/src/json_helper.c b/src/json_helper.c index 2fc94d9..bd37f4f 100644 --- a/src/json_helper.c +++ b/src/json_helper.c @@ -23,15 +23,13 @@ #include /* Utilities */ -json_object * json_copy(json_object ** to_ptr, const char * name, json_object * from, json_object * def) { - json_object * obj; - json_object * to = * to_ptr; - if (json_object_object_get_ex(from, name, &obj)){ - json_object_object_add(to,name,obj); - } else { - json_object_object_add(to,name,def); +json_object * json_copy(json_object * from, bool deep) { + if (!deep){ + return json_object_get(from); } - return to; + return json_tokener_parse( + json_object_to_json_string(from) + ); } /* Getters */ diff --git a/src/json_helper.h b/src/json_helper.h index ee2fbc2..cc7a694 100644 --- a/src/json_helper.h +++ b/src/json_helper.h @@ -47,7 +47,7 @@ struct JSON_HELPER { }; typedef struct JSON_HELPER JSON_HELPER; -json_object * json_copy(json_object **, const char *, json_object *, json_object *); +json_object * json_copy(json_object * from, bool deep); const char * json_get_string(json_object * obj, const char * name); long long int json_get_int(json_object * obj, const char * name, long long int def); diff --git a/src/syncd.c b/src/syncd.c index 900bafb..0283254 100644 --- a/src/syncd.c +++ b/src/syncd.c @@ -72,15 +72,6 @@ json_object * rules; } #endif -json_object * getCacheDetails(int pnum, const char * path) { - const char * plugin_prefix = plugins[pnum].prefix; - json_object * foc = getFileCache(plugin_prefix,path +strlen(plugin_prefix)); - json_object * details = json_object_new_object(); - json_copy(&details,"size",foc, json_object_new_int64(0)); - json_copy(&details, "modified", foc,json_object_new_int64(0)); - return details; -} - char ** free_all(char ** array, int length){ int i; if (array == NULL) length = 0; From 09ecf5a0d040a436ecb4658d3d4b7ba5802ee676 Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 11 Jun 2015 22:29:03 -0400 Subject: [PATCH 13/49] Fixed errors introduced by porting to OS X --- libexec/dropbox.h | 4 ++-- libexec/gdrive_cache.c | 6 ++++-- libexec/syncfs.h | 10 ++++++---- 3 files changed, 12 insertions(+), 8 deletions(-) diff --git a/libexec/dropbox.h b/libexec/dropbox.h index 137482b..5778b53 100644 --- a/libexec/dropbox.h +++ b/libexec/dropbox.h @@ -1,11 +1,11 @@ -#include #define _XOPEN_SOURCE 500 -#define XOPEN_SOURCE #include #include #include #include #include +#undef _XOPEN_SOURCE +#include #include "../libdropbox/dropbox_api.h" #define PLUGIN_PREFIX "dropbox://" diff --git a/libexec/gdrive_cache.c b/libexec/gdrive_cache.c index 7217024..82e7541 100644 --- a/libexec/gdrive_cache.c +++ b/libexec/gdrive_cache.c @@ -1,10 +1,12 @@ -#include #define _XOPEN_SOURCE 500 +#include #include "gdrive_cache.h" +#include "gdrive.h" #include +#undef _XOPEN_SOURCE +#include #include "../libgdrive/gdrive_api.h" #include "../src/os.h" -#include diff --git a/libexec/syncfs.h b/libexec/syncfs.h index a78dbb3..419e424 100644 --- a/libexec/syncfs.h +++ b/libexec/syncfs.h @@ -1,13 +1,15 @@ #ifndef _SYNCFS_H_ #define _SYNCFS_H_ -#include #define _XOPEN_SOURCE 500 -#include -#include #include #include #include +#include +#include +#include +#undef _XOPEN_SOURCE +#include #undef PLUGIN_PREFIX #include /* "readdir" etc. are defined here. */ @@ -15,7 +17,7 @@ /* limits.h defines "PATH_MAX". */ #include #ifndef PATH_MAX -#include + #include #endif #define PLUGIN_PREFIX "file://" #define PLUGIN_PREFIX_LEN 7 From 5d8f1f529d98faef97e4132d153fcd8ddb88cb3f Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 25 Jun 2015 18:44:23 -0400 Subject: [PATCH 14/49] Fixed all major memory leaks. Signed-off-by: Paul Martin --- configure.ac | 4 ++ libdropbox/dropbox_api.c | 10 +++-- libdropbox/dropbox_api.h | 2 +- libexec/Makefile.am | 14 +++++-- libexec/dropbox.c | 29 ++++++++------ libexec/gdrive.c | 53 +++++++++++++++----------- libexec/gdrive_cache.c | 81 ++++++++++++++++++++++------------------ librest/rest.c | 42 ++++++++++++++------- src/cache.c | 18 ++++++--- src/log.c | 4 +- src/syncd.c | 52 +++++++++++++++++--------- 11 files changed, 194 insertions(+), 115 deletions(-) diff --git a/configure.ac b/configure.ac index a5b3d3b..dc23418 100644 --- a/configure.ac +++ b/configure.ac @@ -36,10 +36,14 @@ AC_CHECK_HEADER(sys/inotify.h, HAVE_INOTIFY_H, 1, [Define to 1 if you have .] ) + AM_CONDITIONAL(USE_INOTIFY, true) + AM_CONDITIONAL(USE_LIBUV, false) AC_MSG_NOTICE([Using Inotify for FileSystem Events]) ],[ AC_MSG_NOTICE([No inotify, using libuv as a backup]) AC_CHECK_LIB([uv], [uv_run]) + AM_CONDITIONAL(USE_INOTIFY, false) + AM_CONDITIONAL(USE_LIBUV, true) ]) #wait.h: diff --git a/libdropbox/dropbox_api.c b/libdropbox/dropbox_api.c index dcd0a0c..6e0b04e 100644 --- a/libdropbox/dropbox_api.c +++ b/libdropbox/dropbox_api.c @@ -112,7 +112,6 @@ json_object * db_delta (char* cursor, const char* access_token){ buffer resp = rest_post(params,DELTA); json_object * response = json_tokener_parse(resp.data); -// printf(json_object_to_json_string(response)); buffer_free(resp); free(params[0]); @@ -120,7 +119,7 @@ json_object * db_delta (char* cursor, const char* access_token){ return response; } -const char * db_authorize_token (char* token, char * client_id, char* client_secret){ +char * db_authorize_token (char* token, char * client_id, char* client_secret){ char * params[5]; json_object *access_token; @@ -140,8 +139,13 @@ const char * db_authorize_token (char* token, char * client_id, char* client_sec free(params[3]); if (json_object_object_get_ex(response,"access_token",&access_token)){ - return json_object_get_string(access_token); + + char * at = (char*)(json_object_get_string(access_token)); + if (at != NULL) at = strdup(at); + json_object_put(response); + return at; } + json_object_put(response); //printf("%s\n",json_object_to_json_string(response)); return NULL; } diff --git a/libdropbox/dropbox_api.h b/libdropbox/dropbox_api.h index 1358830..df640d1 100644 --- a/libdropbox/dropbox_api.h +++ b/libdropbox/dropbox_api.h @@ -32,7 +32,7 @@ json_object * db_files_put(const char* path, const char* access_token, FILE * json_object * db_metadata (const char* path, const char* access_token, bool list); json_object * db_delta (char* cursor, const char* access_token); json_object * db_longpoll (const char* cursor,int timeout); -const char * db_authorize_token (char* token, char * client_id, char* client_secret); +char * db_authorize_token (char* token, char * client_id, char* client_secret); json_object * db_mkdir(const char * name, const char * access_token); json_object * db_mv(const char * from, const char * to, const char * access_token); json_object * db_rm(const char * name, const char * access_token); diff --git a/libexec/Makefile.am b/libexec/Makefile.am index 10bf1fd..89144cd 100644 --- a/libexec/Makefile.am +++ b/libexec/Makefile.am @@ -1,12 +1,20 @@ pkglib_LTLIBRARIES = libsyncfs.la libsyncdb.la libsyncgdrive.la -libsyncfs_la_SOURCES = syncfs.c ../src/json_helper.c +if USE_INOTIFY +libsyncfs_la_SOURCES = syncfs.c syncfs.h linuxfs.c ../src/json_helper.c ../src/plugin.c +endif + +if USE_LIBUV +libsyncfs_la_SOURCES = syncfs.c syncfs.h uvfs.c ../src/json_helper.c ../src/plugin.c +endif + +EXTRA_libsyncfs_la_SOURCES = linuxfs.c uvfs.c ../src/plugin.h libsyncfs_la_LDFLAGS = -avoid-version -module -shared -export-dynamic -libsyncdb_la_SOURCES = dropbox.c ../src/json_helper.c +libsyncdb_la_SOURCES = dropbox.c dropbox.h ../src/json_helper.c ../src/plugin.c libsyncdb_la_LIBADD = ../libdropbox/libdropbox.la libsyncdb_la_LDFLAGS = -avoid-version -module -shared -export-dynamic -libsyncgdrive_la_SOURCES = gdrive.c gdrive_cache.h gdrive_cache.c ../src/json_helper.c +libsyncgdrive_la_SOURCES = gdrive.c gdrive.h gdrive_cache.h gdrive_cache.c ../src/json_helper.c ../src/plugin.c libsyncgdrive_la_LIBADD = ../libgdrive/libgdrive.la libsyncgdrive_la_LDFLAGS = -avoid-version -module -shared -export-dynamic diff --git a/libexec/dropbox.c b/libexec/dropbox.c index c8a3fe7..df4c38e 100644 --- a/libexec/dropbox.c +++ b/libexec/dropbox.c @@ -27,7 +27,7 @@ char * client_secret = "ia87pt0ep6dvb7y"; char * access_token; init_args args; utilities utils; -json_object * config; +//json_object * config; json_object * cache; #ifndef HAVE_WAIT_H @@ -60,7 +60,7 @@ char * safe_strdup(const char * str){ } void update_cache(json_object * entry,const char *fname){ - json_object * cfile = utils.getFileCache(PLUGIN_PREFIX,fname); + json_object * cfile = json_object_get(utils.getFileCache(PLUGIN_PREFIX,fname)); if (cfile == NULL) cfile = json_object_new_object(); @@ -115,14 +115,14 @@ const char * init(init_args a){ args = a; utils = args.utils; curl_global_init(CURL_GLOBAL_DEFAULT); - config = utils.getConfig(PLUGIN_PREFIX); + json_object * config = json_copy(utils.getConfig(PLUGIN_PREFIX), true); if (config == NULL){ - config = json_object_new_object(); + config = json_object_get(json_object_new_object()); } access_token = safe_strdup(json_get_string(config, "access_token")); - FILE * state = fopen("access_token.txt", "r"); + //FILE * state = fopen("access_token.txt", "r"); if (access_token == NULL){ - char token[128]; + char token[128]; char cmd[512]; sprintf(cmd, "%s \"%s?response_type=code&client_id=%s\" %s",URL_OPEN_CMD,OAUTH_2_AUTH,client_key, SILENT_CMD); //printf("go to https://www.dropbox.com/1/oauth2/authorize?response_type=code&client_id=%s and copy the code here\n",client_key); @@ -138,18 +138,20 @@ const char * init(init_args a){ if (fgets(token,128,stdin) == NULL) exit(1); int len = strlen(token); if (token[len-1] == '\n') token[len-1] = '\0'; - access_token = safe_strdup(db_authorize_token(token,client_key,client_secret)); + access_token = db_authorize_token(token,client_key,client_secret); if (access_token == NULL) exit(1); json_object * at = json_object_new_string(access_token); args.log(LOGARGS,"config = %s\n",json_object_to_json_string(config)); json_object_object_add(config, "access_token", at); utils.addConfig(PLUGIN_PREFIX, config); } - + json_object_put(config); return PLUGIN_PREFIX; } void sync_unload(){ + args.log("dropbox:sync_unload()", 0, "freeing resources"); + free(access_token); curl_global_cleanup(); } @@ -159,10 +161,11 @@ void sync_listen(int (*cb)(const char*,int)){ static char * cursor; { json_object * jcursor; - config = utils.getConfig(PLUGIN_PREFIX); + json_object * config = json_copy(utils.getConfig(PLUGIN_PREFIX), false); if (json_object_object_get_ex(config, "cursor", &jcursor)){ cursor = strdup(json_object_get_string(jcursor)); } + json_object_put(config); } args.log(LOGARGS,"cursor=%s\n",cursor); bool has_more; @@ -190,6 +193,7 @@ void sync_listen(int (*cb)(const char*,int)){ json_object *entries; if (!json_object_object_get_ex(delta,"entries",&entries)){ args.log(LOGARGS,"no delta['entries']\n"); + json_object_put(delta); free(cursor); cursor=NULL; continue; @@ -224,7 +228,7 @@ void sync_listen(int (*cb)(const char*,int)){ cb(path,S_DELETE); } - //json_object_put(entry); // free the entry + json_object_put(entry); // free the entry } has_more = JSON_GET_BOOL(delta,"has_more",false); @@ -236,9 +240,10 @@ void sync_listen(int (*cb)(const char*,int)){ args.log(LOGARGS,"New Cursor : %s\n\n",new_cursor); args.log(LOGARGS,"========================================================\n\n"); - config = utils.getConfig(PLUGIN_PREFIX); - json_object_object_add(config, "cursor", json_object_new_string(cursor)); + json_object * config = json_copy(utils.getConfig(PLUGIN_PREFIX),false); + json_add_string(config, "cursor", cursor); utils.addConfig(PLUGIN_PREFIX,config); + json_object_put(config); json_object_put(delta); } while (has_more); diff --git a/libexec/gdrive.c b/libexec/gdrive.c index 100a2b4..573b159 100644 --- a/libexec/gdrive.c +++ b/libexec/gdrive.c @@ -20,6 +20,7 @@ */ #include "gdrive.h" +#include bool check_error(json_object* obj); char * mkdirP(const char * path); @@ -50,14 +51,17 @@ json_object * lc_get(){ } void lc_addCache(const char * plugin_prefix, const char * fname, json_object * entry){ - json_object * c = lc_get(); - if (fname != NULL && strlen(fname) != 0 && entry != NULL){ - args.log(LOGARGS,"adding cache entry for %s\n", fname); - //puts(json_object_to_json_string_ext(entry, JSON_C_TO_STRING_PRETTY)); - json_object * cache_entry = json_object_get(entry); - json_object_object_add(c, fname, cache_entry); - //json_object_put(cache_entry); - } + json_object * c = lc_get(); + if (fname != NULL && strlen(fname) != 0 && entry != NULL){ + if (json_object_object_get_ex(c, fname, NULL)){ + json_object_object_del(c, fname); + } + args.log(LOGARGS,"adding cache entry for %s\n", fname); + //puts(json_object_to_json_string_ext(entry, JSON_C_TO_STRING_PRETTY)); + json_object * cache_entry = json_object_get(entry); + json_object_object_add(c, fname, cache_entry); + json_object_put(cache_entry); + } } json_object * lc_getCache(const char * plugin_prefix){ @@ -74,10 +78,10 @@ json_object * lc_getFileCache(const char * plugin_prefix, const char * fname){ } } -int update_cache(const char * id, +int gdrive_update_cache(const char * id, const char * path, json_object * new_metadata){ - json_object * old_metadata = utils.getFileCache(PLUGIN_PREFIX, id); + json_object * old_metadata = utils.getFileCache(PLUGIN_PREFIX, id); bool is_dir = json_get_bool(new_metadata, "is_dir", false); if (old_metadata != NULL){ long long int old_mtime = json_get_int(old_metadata, "modified", 0); @@ -87,7 +91,9 @@ int update_cache(const char * id, return 0; } } else { - if (id) utils.addCache(PLUGIN_PREFIX, id, json_object_get(new_metadata)); + if (id){ + utils.addCache(PLUGIN_PREFIX, id, json_object_get(new_metadata)); + } if (path){ char * clean_path = normalize_path(path, is_dir); utils.addCache(PLUGIN_PREFIX, clean_path, json_object_get(new_metadata)); @@ -112,10 +118,9 @@ int update_cache(const char * id, return 0; } json_add_string(new_metadata, "path", path); - - utils.addCache(PLUGIN_PREFIX, path, json_object_get(new_metadata)); - utils.addCache(PLUGIN_PREFIX, id , new_metadata); - json_object_put(new_metadata); + utils.addCache(PLUGIN_PREFIX, path, json_copy(new_metadata, false)); + utils.addCache(PLUGIN_PREFIX, id , json_copy(new_metadata, false)); + json_object_put(new_metadata); free(path_from_id); return 1; } @@ -331,6 +336,7 @@ const char * init(init_args a){ void sync_unload(){ curl_global_cleanup(); + json_object_put(local_cache); gdrive_cleanup(); } @@ -346,14 +352,16 @@ void get_updates(int (*cb)(const char*,int)){ json_object* lc; json_object * aggregate_changes = json_object_new_object(); - json_object* config = utils.getConfig(PLUGIN_PREFIX); + json_object* config = json_copy(utils.getConfig(PLUGIN_PREFIX), false); if (!json_object_object_get_ex(config,"largest_change",&lc)){ last_change = strdup("0"); } else { last_change = strdup(json_object_get_string(lc)); } + json_object_put(config); if (last_change[0]=='0'){ first_sync = true; + free(last_change); last_change = NULL; } do { @@ -376,9 +384,10 @@ void get_updates(int (*cb)(const char*,int)){ args.log(LOGARGS,"largestchangeID = %ld\n",temp); char largestChangeId[128]; sprintf(largestChangeId,"%ld",temp+1); - config = json_object_get(utils.getConfig(PLUGIN_PREFIX)); + config = json_copy(utils.getConfig(PLUGIN_PREFIX), true); json_object_object_add(config,"largest_change",json_object_new_string(largestChangeId)); utils.addConfig(PLUGIN_PREFIX,config); + json_object_put(config); } json_object * items; if (json_object_object_get_ex(changes, "items",&items)){ @@ -392,7 +401,7 @@ void get_updates(int (*cb)(const char*,int)){ ){ if (strcmp(json_get_string(change, "mimeType"), "application/vnd.google-apps.folder") == 0){ args.log(LOGARGS,"folder id '%s'\n", id); - update_cache(id, NULL, update_metadata(id,change)); + gdrive_update_cache(id, NULL, update_metadata(id,change)); } } } @@ -405,9 +414,9 @@ void get_updates(int (*cb)(const char*,int)){ !json_get_bool(change,"deleted",false) && json_object_object_get_ex(change,"file",&change) ){ - args.log(LOGARGS,"not deleted\n"); + //args.log(LOGARGS,"not deleted\n"); bool is_trashed = json_get_bool(change, "explicitlyTrashed", false); - args.log(LOGARGS,"is_trashed = %s\n", is_trashed? "true":"false"); + //args.log(LOGARGS,"is_trashed = %s\n", is_trashed? "true":"false"); bool can_sync = json_object_object_get_ex(change,"downloadUrl", NULL); if (!is_trashed && !can_sync){ @@ -415,7 +424,7 @@ void get_updates(int (*cb)(const char*,int)){ continue; } - if (update_cache(id, NULL, update_metadata(id,change)) == 0 && !is_trashed){ + if (gdrive_update_cache(id, NULL, update_metadata(id, change)) == 0 && !is_trashed){ continue; } @@ -443,7 +452,7 @@ void get_updates(int (*cb)(const char*,int)){ if (is_trashed){ mask = S_DELETE; update_version(id,path); - args.log(LOGARGS,"file '%s' with id '%s' was trashed\n", path, id); + //args.log(LOGARGS,"file '%s' with id '%s' was trashed\n", path, id); } char * fullPath = (char *) malloc(PLUGIN_PREFIX_LEN + strlen(path) + 2); diff --git a/libexec/gdrive_cache.c b/libexec/gdrive_cache.c index 96ca871..0c8f7a6 100644 --- a/libexec/gdrive_cache.c +++ b/libexec/gdrive_cache.c @@ -3,6 +3,7 @@ #include #include "../libgdrive/gdrive_api.h" #include "../src/os.h" +#include #include #include @@ -66,10 +67,8 @@ json_object * get_metadata(const char* id, const char* path){ json_add_string(file, "path", path); - utils.addCache(PLUGIN_PREFIX, path, json_object_get(file)); utils.addCache(PLUGIN_PREFIX, id , file); - json_object_put(file); free(id_from_path); @@ -79,7 +78,7 @@ json_object * get_metadata(const char* id, const char* path){ json_object * update_metadata( const char * id, json_object * gdrive_meta){ - bool free_metadata = false; + bool free_metadata = false; while(check_error(gdrive_meta)) { gdrive_meta = gdrive_get_metadata(id); free_metadata = true; @@ -96,6 +95,7 @@ json_object * update_metadata( const char * id, json_object * gdrive_meta){ } json_object * file = json_object_new_object(); + args.log(LOGARGS, "update-metadata: refcount %d\n", file->_ref_count); bool is_dir = strcmp( json_get_string(gdrive_meta,"mimeType"), "application/vnd.google-apps.folder" @@ -152,44 +152,53 @@ char * normalize_path(const char * path, bool is_dir){ free(fname); return clean_path; } + char * get_path(const char * id){ - bool free_metadata = false; if (id == NULL) return strdup("/"); if ( strcmp(id, "root") == 0 ) return strdup("/"); - json_object * file = utils.getFileCache(PLUGIN_PREFIX, id); + json_object * file = json_object_get(utils.getFileCache(PLUGIN_PREFIX, id)); if (file == NULL) { - file = update_metadata(id, NULL); - utils.addCache(PLUGIN_PREFIX, id, file); - free_metadata = true; - } - // #DEBUG - //printf("file: \n%s\n", json_object_to_json_string_ext(file, JSON_C_TO_STRING_PRETTY)); - if (json_get_bool(file, "deleted", false)) return NULL; - if (!json_object_object_get_ex(file, "path", NULL)){ - if (json_get_bool(file, "is_root", false)) return strdup("/"); - char * parent_id = safe_strdup(json_get_string(file, "parentID")); - char * title = safe_strdup(json_get_string(file, "title")); - if (title == NULL){ return NULL ;} - bool is_dir = json_get_bool(file, "is_dir", false); - char * path = get_path(parent_id); - - free(parent_id); - - if (path == NULL) return NULL; // deleted - - path = (char*) realloc (path, strlen(path) + strlen(title) + 1 + is_dir); - strcat(path, title); - if (is_dir) strcat(path, "/"); - free(title); - - // cache this data. - get_metadata(id, path); - if (free_metadata) json_object_put(file); - return path; - } - if (free_metadata) json_object_put(file); - return strdup(json_get_string(file, "path")); + file = update_metadata(id, NULL); + utils.addCache(PLUGIN_PREFIX, id, json_object_get(file)); + } + // #DEBUG + //printf("file: \n%s\n", json_object_to_json_string_ext(file, JSON_C_TO_STRING_PRETTY)); + if (json_get_bool(file, "deleted", false)) return NULL; + if (!json_object_object_get_ex(file, "path", NULL)){ + if (json_get_bool(file, "is_root", false)) { + json_object_put(file); + return strdup("/"); + } + char * parent_id = safe_strdup(json_get_string(file, "parentID")); + char * title = safe_strdup(json_get_string(file, "title")); + if (title == NULL){ + json_object_put(file); + return NULL; + } + bool is_dir = json_get_bool(file, "is_dir", false); + char * path = get_path(parent_id); + + free(parent_id); + + if (path == NULL) { + json_object_put(file); + return NULL; // deleted + } + + path = (char*) realloc (path, strlen(path) + strlen(title) + 1 + is_dir); + strcat(path, title); + if (is_dir) strcat(path, "/"); + free(title); + + // cache this data. + get_metadata(id, path); + json_object_put(file); + return path; + } + char * path = safe_strdup(json_get_string(file, "path")); + json_object_put(file); + return path; } char * get_child_id(char * parentId, char * fname){ diff --git a/librest/rest.c b/librest/rest.c index 014f1d6..6939f21 100644 --- a/librest/rest.c +++ b/librest/rest.c @@ -102,10 +102,13 @@ char * rest_escape(char * url){ void * run_curl(void* ptr){ if (ptr != NULL){ run_curl_args * args = (run_curl_args*) ptr; - curl_easy_perform(args->curl); - curl_easy_cleanup(args->curl); + CURLcode res = curl_easy_perform(args->curl); + if (res != CURLE_OK){ + printf("rest_get error: %s\n", curl_easy_strerror(res)); + } fclose(args->file); free(args->url); + curl_easy_cleanup(args->curl); } return NULL; } @@ -204,10 +207,11 @@ buffer rest_get_buffer (char ** params, char * url){ CURLcode res = curl_easy_perform(curl); if (res != CURLE_OK){ //TODO: return better error handling; + printf("rest_get_buffer error: %s\n", curl_easy_strerror(res)); //printf("code = %d, data= %s\n",res,data.data); } - curl_easy_cleanup(curl); free(full_url); + curl_easy_cleanup(curl); return data; } @@ -223,11 +227,12 @@ buffer rest_post (char ** params, char * url){ curl_easy_setopt(curl,CURLOPT_WRITEDATA, &data); curl_easy_setopt(curl,CURLOPT_WRITEFUNCTION,WriteBufferCB); CURLcode res = curl_easy_perform(curl); - if (res != CURLE_OK) - //printf("res = %d, data = %s\n",res,data.data); - curl_easy_cleanup(curl); + if (res != CURLE_OK){ + printf("rest_post error: %s\n", curl_easy_strerror(res)); + } free(post); free(escaped_url); + curl_easy_cleanup(curl); return data; } @@ -250,12 +255,13 @@ buffer rest_post_headers (char ** params, char ** headers, char * url){ CURLcode res = curl_easy_perform(curl); if (res != CURLE_OK){ //TODO: better error handling - //printf("res = &d, data = %s\n",res,data.data); + printf("rest_post_headers error: %s\n", curl_easy_strerror(res)); } - curl_easy_cleanup(curl); - curl_slist_free_all(slist); - free(--post); + post++; + free(post); free(escaped_url); + curl_slist_free_all(slist); + curl_easy_cleanup(curl); return data; } @@ -309,11 +315,14 @@ int rest_post_all(rest_args args){ } //curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L); CURLcode res = curl_easy_perform(curl); - curl_easy_cleanup(curl); + if (res != CURLE_OK){ + printf("rest_post_all error: %s\n", curl_easy_strerror(res)); + } free(post); free(content_type); free(escaped_url); curl_slist_free_all(slist); + curl_easy_cleanup(curl); return res; } @@ -367,10 +376,13 @@ int rest_put_all(rest_args args, FILE * file){ //curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L); CURLcode res = curl_easy_perform(curl); - curl_easy_cleanup(curl); + if (res != CURLE_OK){ + printf("rest_post_all error: %s\n", curl_easy_strerror(res)); + } free(content_type); free(full_url); curl_slist_free_all(slist); + curl_easy_cleanup(curl); return res; } @@ -389,11 +401,12 @@ buffer rest_put_file (char** params, char* url, FILE * in){ curl_easy_setopt(curl,CURLOPT_READFUNCTION,ReadFileCB); // for windows CURLcode res = curl_easy_perform(curl); free(full_url); - curl_easy_cleanup(curl); if (res != CURLE_OK){ //printf("res = %d, data = %.*s\n",res,(int)data.size,data.data); + printf("rest_put_file error: %s\n", curl_easy_strerror(res)); data = buffer_free(data); } + curl_easy_cleanup(curl); return data; } @@ -422,10 +435,11 @@ buffer rest_put_headers (char** params,char** headers, char* url, FILE * in){ CURLcode res = curl_easy_perform(curl); free(full_url); curl_slist_free_all(slist); - curl_easy_cleanup(curl); if (res != CURLE_OK){ + printf("rest_put_headers error: %s\n", curl_easy_strerror(res)); //printf("res = %d, data = %.*s\n",res,(int)data.size,data.data); data = buffer_free(data); } + curl_easy_cleanup(curl); return data; } diff --git a/src/cache.c b/src/cache.c index 84d61d1..f7e82b1 100644 --- a/src/cache.c +++ b/src/cache.c @@ -32,6 +32,7 @@ #include "shared_memory.h" #include "log.h" #include +#include #ifndef MAP_FILE #define MAP_FILE 0 @@ -76,15 +77,17 @@ void cache_init(){ PROT_READ | PROT_WRITE, MAP_FILE|MAP_SHARED, cacheFD, 0); if (cacheFile == MAP_FAILED ) errx(1,"failed"); // setup semaphores. - cache_semaphore = semaphore_create(1, "SYNCD\\cache"); + cache_semaphore = semaphore_create(1, "SYNCD\\cache" ); config_semaphore = semaphore_create(1, "SYNCD\\config"); } void cache_clear(){ munmap(cacheFile, *cacheLength); close(cacheFD); - semaphore_delete(cache_semaphore, "SYNCD\\cache"); - semaphore_delete(config_semaphore, "SYNCD\\cache"); + json_object_put(config); + json_object_put(cache); + semaphore_delete(cache_semaphore , "SYNCD\\cache" ); + semaphore_delete(config_semaphore, "SYNCD\\config"); } json_object * getCache(const char * plugin_prefix){ @@ -107,7 +110,7 @@ json_object * getFileCache(const char * plugin_prefix,const char * fname){ logging_log(LOGARGS,"%s\n",json_object_to_json_string(fcache)); return fcache; } else { - logging_log(LOGARGS," failure\n"); + logging_log(LOGARGS," cache miss.\n"); return NULL; } } @@ -123,6 +126,7 @@ json_object * getConfig(const char * plugin_prefix){ } void addCache(const char * plugin_prefix, const char * fname, json_object * entry){ + printf("addCache: Refcount = %d\n", entry->_ref_count); json_object * cache_entry = json_object_get(entry); json_object * pcache = getCache(plugin_prefix); if (pcache == NULL){/* create cache for plugin*/ @@ -130,12 +134,16 @@ void addCache(const char * plugin_prefix, const char * fname, json_object * entr json_object_object_add(cache, plugin_prefix, pcache); } if (fname != NULL && strlen(fname) != 0 && cache_entry != NULL){ + if (json_object_object_get_ex(pcache, fname, NULL)){ + json_object_object_del(pcache, fname); + } json_object_object_add(pcache, fname, cache_entry); push_cache(); } else { - logging_log(LOGARGS,"addaCache Failed: fname = %s; cache_entry = %s\n",fname,json_object_to_json_string(cache_entry)); + printf("addCache Failed: fname = %s; cache_entry = %s\n",fname,json_object_to_json_string(cache_entry)); } json_object_put(cache_entry); + printf("addCache: Refcount = %d\n", entry->_ref_count); } void updateCache(const char * plugin_prefix, json_object * pcache){ diff --git a/src/log.c b/src/log.c index f551479..c646bd6 100644 --- a/src/log.c +++ b/src/log.c @@ -63,6 +63,6 @@ void logging_close() dup2(__stdout_fd, fileno(stdout)); dup2(__stderr_fd, fileno(stderr)); - close(__stderr_fd); - close(__stdout_fd); + fclose(__stderr); + fclose(__stdout); } diff --git a/src/syncd.c b/src/syncd.c index 0283254..12535a3 100644 --- a/src/syncd.c +++ b/src/syncd.c @@ -150,20 +150,30 @@ int cb(const char * path, int mask){ int pd = get_plugin(sync_path[i]); const char * dest_prefix = plugins[pd].prefix; - json_object * dest_cache = getFileCache(dest_prefix, sync_path[i] + strlen(dest_prefix)); - if (dest_cache == NULL) dest_cache = json_object_new_object(); + + json_object * dest_cache; + { + dest_cache = json_copy( + getFileCache(dest_prefix, sync_path[i] + strlen(dest_prefix)), + false + ); + if (dest_cache == NULL) dest_cache = json_object_new_object(); + } + long long int orig_ver = json_get_int(orig_cache, "version",0); logging_log(LOGARGS,"original version = %lld;",orig_ver); - if ( json_get_int(dest_cache, "version", -1) >= orig_ver){ + if ( json_get_int(dest_cache, "version", -1) >= orig_ver ){ logging_log(LOGARGS,"destination version = %lld\n",json_get_int(dest_cache, "version",-1)); // this file is already in sync + json_object_put(dest_cache); continue; } else { //updateFileCache(plugins[pd].prefix, sync_path[i] + strlen(plugins[pd].prefix),orig_detail); json_object_object_add(dest_cache, "next_version", json_object_new_int64(orig_ver)); addCache(dest_prefix, sync_path[i] + strlen(dest_prefix),json_object_get(dest_cache)); } + if ((mask & S_CREATE ) && (mask & S_DIR)){ logging_log(LOGARGS,"new dir\n"); S_MKDIR sync_mkdir = (S_MKDIR) lt_dlsym(plugins[pd].ptr,"sync_mkdir"); @@ -191,6 +201,7 @@ int cb(const char * path, int mask){ S_MV sync_mv = (S_MV) lt_dlsym(plugins[pd].ptr,"sync_mv"); logging_log(LOGARGS,"moved file %s to %s, returned %d\n",moved_from[i],sync_path[i],sync_mv(moved_from[i],sync_path[i])); } + json_object_put(dest_cache); } if (mask & S_MOVED_TO) moved_from = free_all(moved_from,num_moved_from); sync_path = free_all(sync_path,num_paths); @@ -200,6 +211,7 @@ int cb(const char * path, int mask){ lt_dlhandle loadPlugin(const char * filename ){ const char * ext = strrchr(filename, '.'); + if (ext == NULL) return NULL; // this cannot be a proper plugin name if(strcmp(ext, PLUGIN_EXT) != 0) return NULL; lt_dlhandle out = lt_dlopen(filename); const char * (*get_prefix)() = (const char * (*)()) lt_dlsym (out, "get_prefix"); @@ -223,6 +235,7 @@ lt_dlhandle loadPlugin(const char * filename ){ } logging_log(LOGARGS, "Not loading %.*s plugin from '%s' because it is not referenced in any rule\n", strlen(prefix)-3, prefix, filename); } + lt_dlclose(out); return NULL; } @@ -239,7 +252,7 @@ int loadPlugins(Plugin **return_plugins){ DIR * dp; struct dirent *ep; logging_log(LOGARGS,"looking for plugins in %s\n", LIBDIR ); - dp = opendir(LIBDIR ); //TODO this should pull from config.h + dp = opendir(LIBDIR ); char configPath[PATH_MAX]; strcpy(configPath, getenv("HOME")); strcat(configPath, "/.config/syncd"); @@ -277,6 +290,7 @@ void unloadPlugins(Plugin *plugins, int num){ for (i = 0; i < num; i++){ S_UNLOAD sync_unload = (S_UNLOAD) lt_dlsym(plugins[i].ptr,"sync_unload"); if (sync_unload != NULL) sync_unload(); + lt_dlclose(plugins[i].ptr); } free(plugins); lt_dlexit(); @@ -326,7 +340,7 @@ void setupConfig(){ int main(int argc, char** argv){ //LTDL_SET_PRELOADED_SYMBOLS(); lt_dlinit(); - int plugin_to_run = -1; + int plugin_to_run = -128; { int opt; while (( opt = getopt(argc,argv,"p:")) != -1){ @@ -343,7 +357,7 @@ int main(int argc, char** argv){ num_plugins = loadPlugins(&plugins); logging_stdout("got plugins\n"); int i; - if (plugin_to_run != -1){ + if (plugin_to_run > -1 && plugin_to_run < num_plugins){ S_LISTEN listen =(S_LISTEN) lt_dlsym(plugins[plugin_to_run].ptr,"sync_listen"); json_object_object_foreach(rules,dir,val){ if (get_plugin(dir) == plugin_to_run){// get rules specific to this plugin @@ -352,20 +366,24 @@ int main(int argc, char** argv){ } } listen(cb); - } else for ( i = 0; i < num_plugins; i++){ - S_LISTEN listen =(S_LISTEN) lt_dlsym(plugins[i].ptr,"sync_listen"); - int pid = fork(); - if (pid == 0){ // child - json_object_object_foreach(rules,dir,val){ - if (get_plugin(dir) == i){ // get rules specific to this plugin - logging_log(LOGARGS,"dir=%s\n",dir); - add_watch(dir); + } else if (plugin_to_run == -128){ + for ( i = 0; i < num_plugins; i++){ + S_LISTEN listen =(S_LISTEN) lt_dlsym(plugins[i].ptr,"sync_listen"); + int pid = fork(); + if (pid == 0){ // child + json_object_object_foreach(rules,dir,val){ + if (get_plugin(dir) == i){ // get rules specific to this plugin + logging_log(LOGARGS,"dir=%s\n",dir); + add_watch(dir); + } } - } - listen(cb); - exit(0); + listen(cb); + } } } + + // cleanup unloadPlugins(plugins,num_plugins); cache_clear(); + json_object_put(rules); } From 4885d314996d050ca1ed2305c8951f02a8e6f5e7 Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 25 Jun 2015 18:48:53 -0400 Subject: [PATCH 15/49] Merge memory fixes back into cmake Signed-off-by: Paul Martin --- configure.ac | 4 + libdropbox/dropbox_api.c | 10 +- libdropbox/dropbox_api.h | 2 +- libexec/Makefile.am | 14 +- libexec/dropbox.c | 31 +- libexec/gdrive.c | 54 +- libexec/gdrive_cache.c | 84 +- libexec/syncfs.c | 13 +- librest/CMakeLists.txt | 4 + librest/ca-certificates.crt | 4437 +++++++++++++++++++++++++++++++++++ librest/rest.c | 42 +- src/cache.c | 18 +- src/json_helper.c | 14 +- src/json_helper.h | 2 +- src/log.c | 4 +- src/syncd.c | 61 +- 16 files changed, 4652 insertions(+), 142 deletions(-) create mode 100644 librest/ca-certificates.crt diff --git a/configure.ac b/configure.ac index a5b3d3b..dc23418 100644 --- a/configure.ac +++ b/configure.ac @@ -36,10 +36,14 @@ AC_CHECK_HEADER(sys/inotify.h, HAVE_INOTIFY_H, 1, [Define to 1 if you have .] ) + AM_CONDITIONAL(USE_INOTIFY, true) + AM_CONDITIONAL(USE_LIBUV, false) AC_MSG_NOTICE([Using Inotify for FileSystem Events]) ],[ AC_MSG_NOTICE([No inotify, using libuv as a backup]) AC_CHECK_LIB([uv], [uv_run]) + AM_CONDITIONAL(USE_INOTIFY, false) + AM_CONDITIONAL(USE_LIBUV, true) ]) #wait.h: diff --git a/libdropbox/dropbox_api.c b/libdropbox/dropbox_api.c index dcd0a0c..6e0b04e 100644 --- a/libdropbox/dropbox_api.c +++ b/libdropbox/dropbox_api.c @@ -112,7 +112,6 @@ json_object * db_delta (char* cursor, const char* access_token){ buffer resp = rest_post(params,DELTA); json_object * response = json_tokener_parse(resp.data); -// printf(json_object_to_json_string(response)); buffer_free(resp); free(params[0]); @@ -120,7 +119,7 @@ json_object * db_delta (char* cursor, const char* access_token){ return response; } -const char * db_authorize_token (char* token, char * client_id, char* client_secret){ +char * db_authorize_token (char* token, char * client_id, char* client_secret){ char * params[5]; json_object *access_token; @@ -140,8 +139,13 @@ const char * db_authorize_token (char* token, char * client_id, char* client_sec free(params[3]); if (json_object_object_get_ex(response,"access_token",&access_token)){ - return json_object_get_string(access_token); + + char * at = (char*)(json_object_get_string(access_token)); + if (at != NULL) at = strdup(at); + json_object_put(response); + return at; } + json_object_put(response); //printf("%s\n",json_object_to_json_string(response)); return NULL; } diff --git a/libdropbox/dropbox_api.h b/libdropbox/dropbox_api.h index 1358830..df640d1 100644 --- a/libdropbox/dropbox_api.h +++ b/libdropbox/dropbox_api.h @@ -32,7 +32,7 @@ json_object * db_files_put(const char* path, const char* access_token, FILE * json_object * db_metadata (const char* path, const char* access_token, bool list); json_object * db_delta (char* cursor, const char* access_token); json_object * db_longpoll (const char* cursor,int timeout); -const char * db_authorize_token (char* token, char * client_id, char* client_secret); +char * db_authorize_token (char* token, char * client_id, char* client_secret); json_object * db_mkdir(const char * name, const char * access_token); json_object * db_mv(const char * from, const char * to, const char * access_token); json_object * db_rm(const char * name, const char * access_token); diff --git a/libexec/Makefile.am b/libexec/Makefile.am index 10bf1fd..89144cd 100644 --- a/libexec/Makefile.am +++ b/libexec/Makefile.am @@ -1,12 +1,20 @@ pkglib_LTLIBRARIES = libsyncfs.la libsyncdb.la libsyncgdrive.la -libsyncfs_la_SOURCES = syncfs.c ../src/json_helper.c +if USE_INOTIFY +libsyncfs_la_SOURCES = syncfs.c syncfs.h linuxfs.c ../src/json_helper.c ../src/plugin.c +endif + +if USE_LIBUV +libsyncfs_la_SOURCES = syncfs.c syncfs.h uvfs.c ../src/json_helper.c ../src/plugin.c +endif + +EXTRA_libsyncfs_la_SOURCES = linuxfs.c uvfs.c ../src/plugin.h libsyncfs_la_LDFLAGS = -avoid-version -module -shared -export-dynamic -libsyncdb_la_SOURCES = dropbox.c ../src/json_helper.c +libsyncdb_la_SOURCES = dropbox.c dropbox.h ../src/json_helper.c ../src/plugin.c libsyncdb_la_LIBADD = ../libdropbox/libdropbox.la libsyncdb_la_LDFLAGS = -avoid-version -module -shared -export-dynamic -libsyncgdrive_la_SOURCES = gdrive.c gdrive_cache.h gdrive_cache.c ../src/json_helper.c +libsyncgdrive_la_SOURCES = gdrive.c gdrive.h gdrive_cache.h gdrive_cache.c ../src/json_helper.c ../src/plugin.c libsyncgdrive_la_LIBADD = ../libgdrive/libgdrive.la libsyncgdrive_la_LDFLAGS = -avoid-version -module -shared -export-dynamic diff --git a/libexec/dropbox.c b/libexec/dropbox.c index e16b934..df4c38e 100644 --- a/libexec/dropbox.c +++ b/libexec/dropbox.c @@ -27,7 +27,7 @@ char * client_secret = "ia87pt0ep6dvb7y"; char * access_token; init_args args; utilities utils; -json_object * config; +//json_object * config; json_object * cache; #ifndef HAVE_WAIT_H @@ -60,7 +60,7 @@ char * safe_strdup(const char * str){ } void update_cache(json_object * entry,const char *fname){ - json_object * cfile = utils.getFileCache(PLUGIN_PREFIX,fname); + json_object * cfile = json_object_get(utils.getFileCache(PLUGIN_PREFIX,fname)); if (cfile == NULL) cfile = json_object_new_object(); @@ -92,8 +92,6 @@ void update_cache(json_object * entry,const char *fname){ } size = json_object_new_int64(json_object_get_int64(size)); // copy args.log(LOGARGS,"size : %ld\n",json_object_get_int64(size)); - - // json_copy(&cfile, "rev", entry, json_object_new_string("blank")); { const char *rev; if ((rev = json_get_string(entry,"rev"))==NULL){ @@ -117,14 +115,14 @@ const char * init(init_args a){ args = a; utils = args.utils; curl_global_init(CURL_GLOBAL_DEFAULT); - config = utils.getConfig(PLUGIN_PREFIX); + json_object * config = json_copy(utils.getConfig(PLUGIN_PREFIX), true); if (config == NULL){ - config = json_object_new_object(); + config = json_object_get(json_object_new_object()); } access_token = safe_strdup(json_get_string(config, "access_token")); - FILE * state = fopen("access_token.txt", "r"); + //FILE * state = fopen("access_token.txt", "r"); if (access_token == NULL){ - char token[128]; + char token[128]; char cmd[512]; sprintf(cmd, "%s \"%s?response_type=code&client_id=%s\" %s",URL_OPEN_CMD,OAUTH_2_AUTH,client_key, SILENT_CMD); //printf("go to https://www.dropbox.com/1/oauth2/authorize?response_type=code&client_id=%s and copy the code here\n",client_key); @@ -140,18 +138,20 @@ const char * init(init_args a){ if (fgets(token,128,stdin) == NULL) exit(1); int len = strlen(token); if (token[len-1] == '\n') token[len-1] = '\0'; - access_token = safe_strdup(db_authorize_token(token,client_key,client_secret)); + access_token = db_authorize_token(token,client_key,client_secret); if (access_token == NULL) exit(1); json_object * at = json_object_new_string(access_token); args.log(LOGARGS,"config = %s\n",json_object_to_json_string(config)); json_object_object_add(config, "access_token", at); utils.addConfig(PLUGIN_PREFIX, config); } - + json_object_put(config); return PLUGIN_PREFIX; } void sync_unload(){ + args.log("dropbox:sync_unload()", 0, "freeing resources"); + free(access_token); curl_global_cleanup(); } @@ -161,10 +161,11 @@ void sync_listen(int (*cb)(const char*,int)){ static char * cursor; { json_object * jcursor; - config = utils.getConfig(PLUGIN_PREFIX); + json_object * config = json_copy(utils.getConfig(PLUGIN_PREFIX), false); if (json_object_object_get_ex(config, "cursor", &jcursor)){ cursor = strdup(json_object_get_string(jcursor)); } + json_object_put(config); } args.log(LOGARGS,"cursor=%s\n",cursor); bool has_more; @@ -192,6 +193,7 @@ void sync_listen(int (*cb)(const char*,int)){ json_object *entries; if (!json_object_object_get_ex(delta,"entries",&entries)){ args.log(LOGARGS,"no delta['entries']\n"); + json_object_put(delta); free(cursor); cursor=NULL; continue; @@ -226,7 +228,7 @@ void sync_listen(int (*cb)(const char*,int)){ cb(path,S_DELETE); } - //json_object_put(entry); // free the entry + json_object_put(entry); // free the entry } has_more = JSON_GET_BOOL(delta,"has_more",false); @@ -238,9 +240,10 @@ void sync_listen(int (*cb)(const char*,int)){ args.log(LOGARGS,"New Cursor : %s\n\n",new_cursor); args.log(LOGARGS,"========================================================\n\n"); - config = utils.getConfig(PLUGIN_PREFIX); - json_object_object_add(config, "cursor", json_object_new_string(cursor)); + json_object * config = json_copy(utils.getConfig(PLUGIN_PREFIX),false); + json_add_string(config, "cursor", cursor); utils.addConfig(PLUGIN_PREFIX,config); + json_object_put(config); json_object_put(delta); } while (has_more); diff --git a/libexec/gdrive.c b/libexec/gdrive.c index 0dba02a..573b159 100644 --- a/libexec/gdrive.c +++ b/libexec/gdrive.c @@ -20,6 +20,8 @@ */ #include "gdrive.h" +#include + bool check_error(json_object* obj); char * mkdirP(const char * path); @@ -49,14 +51,17 @@ json_object * lc_get(){ } void lc_addCache(const char * plugin_prefix, const char * fname, json_object * entry){ - json_object * c = lc_get(); - if (fname != NULL && strlen(fname) != 0 && entry != NULL){ - args.log(LOGARGS,"adding cache entry for %s\n", fname); - //puts(json_object_to_json_string_ext(entry, JSON_C_TO_STRING_PRETTY)); - json_object * cache_entry = json_object_get(entry); - json_object_object_add(c, fname, cache_entry); - //json_object_put(cache_entry); - } + json_object * c = lc_get(); + if (fname != NULL && strlen(fname) != 0 && entry != NULL){ + if (json_object_object_get_ex(c, fname, NULL)){ + json_object_object_del(c, fname); + } + args.log(LOGARGS,"adding cache entry for %s\n", fname); + //puts(json_object_to_json_string_ext(entry, JSON_C_TO_STRING_PRETTY)); + json_object * cache_entry = json_object_get(entry); + json_object_object_add(c, fname, cache_entry); + json_object_put(cache_entry); + } } json_object * lc_getCache(const char * plugin_prefix){ @@ -73,10 +78,10 @@ json_object * lc_getFileCache(const char * plugin_prefix, const char * fname){ } } -int update_cache(const char * id, +int gdrive_update_cache(const char * id, const char * path, json_object * new_metadata){ - json_object * old_metadata = utils.getFileCache(PLUGIN_PREFIX, id); + json_object * old_metadata = utils.getFileCache(PLUGIN_PREFIX, id); bool is_dir = json_get_bool(new_metadata, "is_dir", false); if (old_metadata != NULL){ long long int old_mtime = json_get_int(old_metadata, "modified", 0); @@ -86,7 +91,9 @@ int update_cache(const char * id, return 0; } } else { - if (id) utils.addCache(PLUGIN_PREFIX, id, json_object_get(new_metadata)); + if (id){ + utils.addCache(PLUGIN_PREFIX, id, json_object_get(new_metadata)); + } if (path){ char * clean_path = normalize_path(path, is_dir); utils.addCache(PLUGIN_PREFIX, clean_path, json_object_get(new_metadata)); @@ -111,10 +118,9 @@ int update_cache(const char * id, return 0; } json_add_string(new_metadata, "path", path); - - utils.addCache(PLUGIN_PREFIX, path, json_object_get(new_metadata)); - utils.addCache(PLUGIN_PREFIX, id , new_metadata); - json_object_put(new_metadata); + utils.addCache(PLUGIN_PREFIX, path, json_copy(new_metadata, false)); + utils.addCache(PLUGIN_PREFIX, id , json_copy(new_metadata, false)); + json_object_put(new_metadata); free(path_from_id); return 1; } @@ -330,6 +336,7 @@ const char * init(init_args a){ void sync_unload(){ curl_global_cleanup(); + json_object_put(local_cache); gdrive_cleanup(); } @@ -345,14 +352,16 @@ void get_updates(int (*cb)(const char*,int)){ json_object* lc; json_object * aggregate_changes = json_object_new_object(); - json_object* config = utils.getConfig(PLUGIN_PREFIX); + json_object* config = json_copy(utils.getConfig(PLUGIN_PREFIX), false); if (!json_object_object_get_ex(config,"largest_change",&lc)){ last_change = strdup("0"); } else { last_change = strdup(json_object_get_string(lc)); } + json_object_put(config); if (last_change[0]=='0'){ first_sync = true; + free(last_change); last_change = NULL; } do { @@ -375,9 +384,10 @@ void get_updates(int (*cb)(const char*,int)){ args.log(LOGARGS,"largestchangeID = %ld\n",temp); char largestChangeId[128]; sprintf(largestChangeId,"%ld",temp+1); - config = json_object_get(utils.getConfig(PLUGIN_PREFIX)); + config = json_copy(utils.getConfig(PLUGIN_PREFIX), true); json_object_object_add(config,"largest_change",json_object_new_string(largestChangeId)); utils.addConfig(PLUGIN_PREFIX,config); + json_object_put(config); } json_object * items; if (json_object_object_get_ex(changes, "items",&items)){ @@ -391,7 +401,7 @@ void get_updates(int (*cb)(const char*,int)){ ){ if (strcmp(json_get_string(change, "mimeType"), "application/vnd.google-apps.folder") == 0){ args.log(LOGARGS,"folder id '%s'\n", id); - update_cache(id, NULL, update_metadata(id,change)); + gdrive_update_cache(id, NULL, update_metadata(id,change)); } } } @@ -404,9 +414,9 @@ void get_updates(int (*cb)(const char*,int)){ !json_get_bool(change,"deleted",false) && json_object_object_get_ex(change,"file",&change) ){ - args.log(LOGARGS,"not deleted\n"); + //args.log(LOGARGS,"not deleted\n"); bool is_trashed = json_get_bool(change, "explicitlyTrashed", false); - args.log(LOGARGS,"is_trashed = %s\n", is_trashed? "true":"false"); + //args.log(LOGARGS,"is_trashed = %s\n", is_trashed? "true":"false"); bool can_sync = json_object_object_get_ex(change,"downloadUrl", NULL); if (!is_trashed && !can_sync){ @@ -414,7 +424,7 @@ void get_updates(int (*cb)(const char*,int)){ continue; } - if (update_cache(id, NULL, update_metadata(id,change)) == 0 && !is_trashed){ + if (gdrive_update_cache(id, NULL, update_metadata(id, change)) == 0 && !is_trashed){ continue; } @@ -442,7 +452,7 @@ void get_updates(int (*cb)(const char*,int)){ if (is_trashed){ mask = S_DELETE; update_version(id,path); - args.log(LOGARGS,"file '%s' with id '%s' was trashed\n", path, id); + //args.log(LOGARGS,"file '%s' with id '%s' was trashed\n", path, id); } char * fullPath = (char *) malloc(PLUGIN_PREFIX_LEN + strlen(path) + 2); diff --git a/libexec/gdrive_cache.c b/libexec/gdrive_cache.c index 82e7541..4de271e 100644 --- a/libexec/gdrive_cache.c +++ b/libexec/gdrive_cache.c @@ -7,7 +7,9 @@ #include #include "../libgdrive/gdrive_api.h" #include "../src/os.h" - +#include +#include +#include #define PLUGIN_PREFIX "gdrive://" @@ -69,10 +71,8 @@ json_object * get_metadata(const char* id, const char* path){ json_add_string(file, "path", path); - utils.addCache(PLUGIN_PREFIX, path, json_object_get(file)); utils.addCache(PLUGIN_PREFIX, id , file); - json_object_put(file); free(id_from_path); @@ -82,7 +82,7 @@ json_object * get_metadata(const char* id, const char* path){ json_object * update_metadata( const char * id, json_object * gdrive_meta){ - bool free_metadata = false; + bool free_metadata = false; while(check_error(gdrive_meta)) { gdrive_meta = gdrive_get_metadata(id); free_metadata = true; @@ -99,6 +99,7 @@ json_object * update_metadata( const char * id, json_object * gdrive_meta){ } json_object * file = json_object_new_object(); + args.log(LOGARGS, "update-metadata: refcount %d\n", file->_ref_count); bool is_dir = strcmp( json_get_string(gdrive_meta,"mimeType"), "application/vnd.google-apps.folder" @@ -155,44 +156,53 @@ char * normalize_path(const char * path, bool is_dir){ free(fname); return clean_path; } + char * get_path(const char * id){ - bool free_metadata = false; if (id == NULL) return strdup("/"); if ( strcmp(id, "root") == 0 ) return strdup("/"); - json_object * file = utils.getFileCache(PLUGIN_PREFIX, id); + json_object * file = json_object_get(utils.getFileCache(PLUGIN_PREFIX, id)); if (file == NULL) { - file = update_metadata(id, NULL); - utils.addCache(PLUGIN_PREFIX, id, file); - free_metadata = true; - } - // #DEBUG - //printf("file: \n%s\n", json_object_to_json_string_ext(file, JSON_C_TO_STRING_PRETTY)); - if (json_get_bool(file, "deleted", false)) return NULL; - if (!json_object_object_get_ex(file, "path", NULL)){ - if (json_get_bool(file, "is_root", false)) return strdup("/"); - char * parent_id = safe_strdup(json_get_string(file, "parentID")); - char * title = safe_strdup(json_get_string(file, "title")); - if (title == NULL){ return NULL ;} - bool is_dir = json_get_bool(file, "is_dir", false); - char * path = get_path(parent_id); - - free(parent_id); - - if (path == NULL) return NULL; // deleted - - path = (char*) realloc (path, strlen(path) + strlen(title) + 1 + is_dir); - strcat(path, title); - if (is_dir) strcat(path, "/"); - free(title); - - // cache this data. - get_metadata(id, path); - if (free_metadata) json_object_put(file); - return path; - } - if (free_metadata) json_object_put(file); - return strdup(json_get_string(file, "path")); + file = update_metadata(id, NULL); + utils.addCache(PLUGIN_PREFIX, id, json_object_get(file)); + } + // #DEBUG + //printf("file: \n%s\n", json_object_to_json_string_ext(file, JSON_C_TO_STRING_PRETTY)); + if (json_get_bool(file, "deleted", false)) return NULL; + if (!json_object_object_get_ex(file, "path", NULL)){ + if (json_get_bool(file, "is_root", false)) { + json_object_put(file); + return strdup("/"); + } + char * parent_id = safe_strdup(json_get_string(file, "parentID")); + char * title = safe_strdup(json_get_string(file, "title")); + if (title == NULL){ + json_object_put(file); + return NULL; + } + bool is_dir = json_get_bool(file, "is_dir", false); + char * path = get_path(parent_id); + + free(parent_id); + + if (path == NULL) { + json_object_put(file); + return NULL; // deleted + } + + path = (char*) realloc (path, strlen(path) + strlen(title) + 1 + is_dir); + strcat(path, title); + if (is_dir) strcat(path, "/"); + free(title); + + // cache this data. + get_metadata(id, path); + json_object_put(file); + return path; + } + char * path = safe_strdup(json_get_string(file, "path")); + json_object_put(file); + return path; } char * get_child_id(char * parentId, char * fname){ diff --git a/libexec/syncfs.c b/libexec/syncfs.c index ae7d1f8..c298841 100644 --- a/libexec/syncfs.c +++ b/libexec/syncfs.c @@ -34,7 +34,7 @@ int update_file_cache(char * filename, int update){ int metadata_changed = 0; struct stat details; args.log(LOGARGS,"filename = %s\n",filename); - json_object * cache_entry = json_object_get(utils.getFileCache(PLUGIN_PREFIX,filename)); + json_object * cache_entry = json_copy(utils.getFileCache(PLUGIN_PREFIX,filename),false); if (cache_entry == NULL){ metadata_changed = S_CREATE; args.log(LOGARGS,"cache was null for %s\n",filename); @@ -142,8 +142,9 @@ void watch_dir_recurse(char * dir_name){ } void watch_dir (char * dir_name){ - dir_name += PLUGIN_PREFIX_LEN; - sync_mkdir(dir_name); + args.log(LOGARGS, "syncFS:watch_dir(%s)\n", dir_name); + sync_mkdir(dir_name); + dir_name += PLUGIN_PREFIX_LEN; watch_dir_recurse(dir_name); } @@ -190,12 +191,12 @@ int mkpath(char* file_path, mode_t mode) { char* p; for (p=strchr(file_path+1, '/'); p; p=strchr(p+1, '/')) { *p='\0'; - + if (mkdir( - file_path + file_path #ifndef WIN32 ,mode -#endif +#endif )==-1) { if (errno!=EEXIST) { *p='/'; return -1; } } diff --git a/librest/CMakeLists.txt b/librest/CMakeLists.txt index 1ef11e9..d1381e6 100644 --- a/librest/CMakeLists.txt +++ b/librest/CMakeLists.txt @@ -4,3 +4,7 @@ include_directories(${CURL_INCLUDE_DIRS}) add_library(rest rest.c buffer.c) set_property(TARGET rest PROPERTY POSITION_INDEPENDENT_CODE ON) target_link_libraries(rest LINK_PUBLIC ${CURL_LIBRARIES}) + +if(WIN32) +install() +endif() diff --git a/librest/ca-certificates.crt b/librest/ca-certificates.crt new file mode 100644 index 0000000..d77c06e --- /dev/null +++ b/librest/ca-certificates.crt @@ -0,0 +1,4437 @@ +-----BEGIN CERTIFICATE----- +MIIDzzCCAregAwIBAgIDAWweMA0GCSqGSIb3DQEBBQUAMIGNMQswCQYDVQQGEwJB +VDFIMEYGA1UECgw/QS1UcnVzdCBHZXMuIGYuIFNpY2hlcmhlaXRzc3lzdGVtZSBp +bSBlbGVrdHIuIERhdGVudmVya2VociBHbWJIMRkwFwYDVQQLDBBBLVRydXN0LW5R +dWFsLTAzMRkwFwYDVQQDDBBBLVRydXN0LW5RdWFsLTAzMB4XDTA1MDgxNzIyMDAw +MFoXDTE1MDgxNzIyMDAwMFowgY0xCzAJBgNVBAYTAkFUMUgwRgYDVQQKDD9BLVRy +dXN0IEdlcy4gZi4gU2ljaGVyaGVpdHNzeXN0ZW1lIGltIGVsZWt0ci4gRGF0ZW52 +ZXJrZWhyIEdtYkgxGTAXBgNVBAsMEEEtVHJ1c3QtblF1YWwtMDMxGTAXBgNVBAMM +EEEtVHJ1c3QtblF1YWwtMDMwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB +AQCtPWFuA/OQO8BBC4SAzewqo51ru27CQoT3URThoKgtUaNR8t4j8DRE/5TrzAUj +lUC5B3ilJfYKvUWG6Nm9wASOhURh73+nyfrBJcyFLGM/BWBzSQXgYHiVEEvc+RFZ +znF/QJuKqiTfC0Li21a8StKlDJu3Qz7dg9MmEALP6iPESU7l0+m0iKsMrmKS1GWH +2WrX9IWf5DMiJaXlyDO6w8dB3F/GaswADm0yqLaHNgBid5seHzTLkDx4iHQF63n1 +k3Flyp3HaxgtPVxO59X4PzF9j4fsCiIvI+n+u33J4PTs63zEsMMtYrWacdaxaujs +2e3Vcuy+VwHOBVWf3tFgiBCzAgMBAAGjNjA0MA8GA1UdEwEB/wQFMAMBAf8wEQYD +VR0OBAoECERqlWdVeRFPMA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQUFAAOC +AQEAVdRU0VlIXLOThaq/Yy/kgM40ozRiPvbY7meIMQQDbwvUB/tOdQ/TLtPAF8fG +KOwGDREkDg6lXb+MshOWcdzUzg4NCmgybLlBMRmrsQd7TZjTXLDR8KdCoLXEjq/+ +8T/0709GAHbrAvv5ndJAlseIOrifEXnzgGWovR/TeIGgUUw3tKZdJXDRZslo+S4R +FGjxVJgIrCaSD96JntT6s3kr0qN51OyLrIdTaEJMUVF0HhsnLuP1Hyl0Te2v9+GS +mYHovjrHF1D2t8b8m7CKa9aIA5GPBnc6hQLdmNVDeD/GMBWsm2vLV7eJUYs66MmE +DNuxUCAKGkq6ahq97BvIxYSazQ== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIH0zCCBbugAwIBAgIIXsO3pkN/pOAwDQYJKoZIhvcNAQEFBQAwQjESMBAGA1UE +AwwJQUNDVlJBSVoxMRAwDgYDVQQLDAdQS0lBQ0NWMQ0wCwYDVQQKDARBQ0NWMQsw +CQYDVQQGEwJFUzAeFw0xMTA1MDUwOTM3MzdaFw0zMDEyMzEwOTM3MzdaMEIxEjAQ +BgNVBAMMCUFDQ1ZSQUlaMTEQMA4GA1UECwwHUEtJQUNDVjENMAsGA1UECgwEQUND +VjELMAkGA1UEBhMCRVMwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCb +qau/YUqXry+XZpp0X9DZlv3P4uRm7x8fRzPCRKPfmt4ftVTdFXxpNRFvu8gMjmoY +HtiP2Ra8EEg2XPBjs5BaXCQ316PWywlxufEBcoSwfdtNgM3802/J+Nq2DoLSRYWo +G2ioPej0RGy9ocLLA76MPhMAhN9KSMDjIgro6TenGEyxCQ0jVn8ETdkXhBilyNpA +lHPrzg5XPAOBOp0KoVdDaaxXbXmQeOW1tDvYvEyNKKGno6e6Ak4l0Squ7a4DIrhr +IA8wKFSVf+DuzgpmndFALW4ir50awQUZ0m/A8p/4e7MCQvtQqR0tkw8jq8bBD5L/ +0KIV9VMJcRz/RROE5iZe+OCIHAr8Fraocwa48GOEAqDGWuzndN9wrqODJerWx5eH +k6fGioozl2A3ED6XPm4pFdahD9GILBKfb6qkxkLrQaLjlUPTAYVtjrs78yM2x/47 +4KElB0iryYl0/wiPgL/AlmXz7uxLaL2diMMxs0Dx6M/2OLuc5NF/1OVYm3z61PMO +m3WR5LpSLhl+0fXNWhn8ugb2+1KoS5kE3fj5tItQo05iifCHJPqDQsGH+tUtKSpa +cXpkatcnYGMN285J9Y0fkIkyF/hzQ7jSWpOGYdbhdQrqeWZ2iE9x6wQl1gpaepPl +uUsXQA+xtrn13k/c4LOsOxFwYIRKQ26ZIMApcQrAZQIDAQABo4ICyzCCAscwfQYI +KwYBBQUHAQEEcTBvMEwGCCsGAQUFBzAChkBodHRwOi8vd3d3LmFjY3YuZXMvZmls +ZWFkbWluL0FyY2hpdm9zL2NlcnRpZmljYWRvcy9yYWl6YWNjdjEuY3J0MB8GCCsG +AQUFBzABhhNodHRwOi8vb2NzcC5hY2N2LmVzMB0GA1UdDgQWBBTSh7Tj3zcnk1X2 +VuqB5TbMjB4/vTAPBgNVHRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFNKHtOPfNyeT +VfZW6oHlNsyMHj+9MIIBcwYDVR0gBIIBajCCAWYwggFiBgRVHSAAMIIBWDCCASIG +CCsGAQUFBwICMIIBFB6CARAAQQB1AHQAbwByAGkAZABhAGQAIABkAGUAIABDAGUA +cgB0AGkAZgBpAGMAYQBjAGkA8wBuACAAUgBhAO0AegAgAGQAZQAgAGwAYQAgAEEA +QwBDAFYAIAAoAEEAZwBlAG4AYwBpAGEAIABkAGUAIABUAGUAYwBuAG8AbABvAGcA +7QBhACAAeQAgAEMAZQByAHQAaQBmAGkAYwBhAGMAaQDzAG4AIABFAGwAZQBjAHQA +cgDzAG4AaQBjAGEALAAgAEMASQBGACAAUQA0ADYAMAAxADEANQA2AEUAKQAuACAA +QwBQAFMAIABlAG4AIABoAHQAdABwADoALwAvAHcAdwB3AC4AYQBjAGMAdgAuAGUA +czAwBggrBgEFBQcCARYkaHR0cDovL3d3dy5hY2N2LmVzL2xlZ2lzbGFjaW9uX2Mu +aHRtMFUGA1UdHwROMEwwSqBIoEaGRGh0dHA6Ly93d3cuYWNjdi5lcy9maWxlYWRt +aW4vQXJjaGl2b3MvY2VydGlmaWNhZG9zL3JhaXphY2N2MV9kZXIuY3JsMA4GA1Ud +DwEB/wQEAwIBBjAXBgNVHREEEDAOgQxhY2N2QGFjY3YuZXMwDQYJKoZIhvcNAQEF +BQADggIBAJcxAp/n/UNnSEQU5CmH7UwoZtCPNdpNYbdKl02125DgBS4OxnnQ8pdp +D70ER9m+27Up2pvZrqmZ1dM8MJP1jaGo/AaNRPTKFpV8M9xii6g3+CfYCS0b78gU +JyCpZET/LtZ1qmxNYEAZSUNUY9rizLpm5U9EelvZaoErQNV/+QEnWCzI7UiRfD+m +AM/EKXMRNt6GGT6d7hmKG9Ww7Y49nCrADdg9ZuM8Db3VlFzi4qc1GwQA9j9ajepD +vV+JHanBsMyZ4k0ACtrJJ1vnE5Bc5PUzolVt3OAJTS+xJlsndQAJxGJ3KQhfnlms +tn6tn1QwIgPBHnFk/vk4CpYY3QIUrCPLBhwepH2NDd4nQeit2hW3sCPdK6jT2iWH +7ehVRE2I9DZ+hJp4rPcOVkkO1jMl1oRQQmwgEh0q1b688nCBpHBgvgW1m54ERL5h +I6zppSSMEYCUWqKiuUnSwdzRp+0xESyeGabu4VXhwOrPDYTkF7eifKXeVSUG7szA +h1xA2syVP1XgNce4hL60Xc16gwFy7ofmXx2utYXGJt/mwZrpHgJHnyqobalbz+xF +d3+YJ5oyXSrjhO7FmGYvliAd3djDJ9ew+f7Zfc3Qn48LFFhRny+Lwzgt3uiP1o2H +pPVWQxaZLPSkVrQ0uGE3ycJYgBugl6H8WY3pEfbRD0tVNEYqi4Y7 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFtTCCA52gAwIBAgIIYY3HhjsBggUwDQYJKoZIhvcNAQEFBQAwRDEWMBQGA1UE +AwwNQUNFRElDT00gUm9vdDEMMAoGA1UECwwDUEtJMQ8wDQYDVQQKDAZFRElDT00x +CzAJBgNVBAYTAkVTMB4XDTA4MDQxODE2MjQyMloXDTI4MDQxMzE2MjQyMlowRDEW +MBQGA1UEAwwNQUNFRElDT00gUm9vdDEMMAoGA1UECwwDUEtJMQ8wDQYDVQQKDAZF +RElDT00xCzAJBgNVBAYTAkVTMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKC +AgEA/5KV4WgGdrQsyFhIyv2AVClVYyT/kGWbEHV7w2rbYgIB8hiGtXxaOLHkWLn7 +09gtn70yN78sFW2+tfQh0hOR2QetAQXW8713zl9CgQr5auODAKgrLlUTY4HKRxx7 +XBZXehuDYAQ6PmXDzQHe3qTWDLqO3tkE7hdWIpuPY/1NFgu3e3eM+SW10W2ZEi5P +Grjm6gSSrj0RuVFCPYewMYWveVqc/udOXpJPQ/yrOq2lEiZmueIM15jO1FillUAK +t0SdE3QrwqXrIhWYENiLxQSfHY9g5QYbm8+5eaA9oiM/Qj9r+hwDezCNzmzAv+Yb +X79nuIQZ1RXve8uQNjFiybwCq0Zfm/4aaJQ0PZCOrfbkHQl/Sog4P75n/TSW9R28 +MHTLOO7VbKvU/PQAtwBbhTIWdjPp2KOZnQUAqhbm84F9b32qhm2tFXTTxKJxqvQU +fecyuB+81fFOvW8XAjnXDpVCOscAPukmYxHqC9FK/xidstd7LzrZlvvoHpKuE1XI +2Sf23EgbsCTBheN3nZqk8wwRHQ3ItBTutYJXCb8gWH8vIiPYcMt5bMlL8qkqyPyH +K9caUPgn6C9D4zq92Fdx/c6mUlv53U3t5fZvie27k5x2IXXwkkwp9y+cAS7+UEae +ZAwUswdbxcJzbPEHXEUkFDWug/FqTYl6+rPYLWbwNof1K1MCAwEAAaOBqjCBpzAP +BgNVHRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFKaz4SsrSbbXc6GqlPUB53NlTKxQ +MA4GA1UdDwEB/wQEAwIBhjAdBgNVHQ4EFgQUprPhKytJttdzoaqU9QHnc2VMrFAw +RAYDVR0gBD0wOzA5BgRVHSAAMDEwLwYIKwYBBQUHAgEWI2h0dHA6Ly9hY2VkaWNv +bS5lZGljb21ncm91cC5jb20vZG9jMA0GCSqGSIb3DQEBBQUAA4ICAQDOLAtSUWIm +fQwng4/F9tqgaHtPkl7qpHMyEVNEskTLnewPeUKzEKbHDZ3Ltvo/Onzqv4hTGzz3 +gvoFNTPhNahXwOf9jU8/kzJPeGYDdwdY6ZXIfj7QeQCM8htRM5u8lOk6e25SLTKe +I6RF+7YuE7CLGLHdztUdp0J/Vb77W7tH1PwkzQSulgUV1qzOMPPKC8W64iLgpq0i +5ALudBF/TP94HTXa5gI06xgSYXcGCRZj6hitoocf8seACQl1ThCojz2GuHURwCRi +ipZ7SkXp7FnFvmuD5uHorLUwHv4FB4D54SMNUI8FmP8sX+g7tq3PgbUhh8oIKiMn +MCArz+2UW6yyetLHKKGKC5tNSixthT8Jcjxn4tncB7rrZXtaAWPWkFtPF2Y9fwsZ +o5NjEFIqnxQWWOLcpfShFosOkYuByptZ+thrkQdlVV9SH686+5DdaaVbnG0OLLb6 +zqylfDJKZ0DcMDQj3dcEI2bw/FWAp/tmGYI1Z2JwOV5vx+qQQEQIHriy1tvuWacN +GHk0vFQYXlPKNFHtRQrmjseCNj6nOGOpMCwXEGCSn1WHElkQwg9naRHMTh5+Spqt +r0CodaxWkHS4oJyleW/c6RrIaQXpuvoDs3zk4E7Czp3otkYNbn5XOmeUwssfnHdK +Z05phkOTOPu220+DkdRgfks+KzgHVZhepA== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFuzCCA6OgAwIBAgIIVwoRl0LE48wwDQYJKoZIhvcNAQELBQAwazELMAkGA1UE +BhMCSVQxDjAMBgNVBAcMBU1pbGFuMSMwIQYDVQQKDBpBY3RhbGlzIFMucC5BLi8w +MzM1ODUyMDk2NzEnMCUGA1UEAwweQWN0YWxpcyBBdXRoZW50aWNhdGlvbiBSb290 +IENBMB4XDTExMDkyMjExMjIwMloXDTMwMDkyMjExMjIwMlowazELMAkGA1UEBhMC +SVQxDjAMBgNVBAcMBU1pbGFuMSMwIQYDVQQKDBpBY3RhbGlzIFMucC5BLi8wMzM1 +ODUyMDk2NzEnMCUGA1UEAwweQWN0YWxpcyBBdXRoZW50aWNhdGlvbiBSb290IENB +MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAp8bEpSmkLO/lGMWwUKNv +UTufClrJwkg4CsIcoBh/kbWHuUA/3R1oHwiD1S0eiKD4j1aPbZkCkpAW1V8IbInX +4ay8IMKx4INRimlNAJZaby/ARH6jDuSRzVju3PvHHkVH3Se5CAGfpiEd9UEtL0z9 +KK3giq0itFZljoZUj5NDKd45RnijMCO6zfB9E1fAXdKDa0hMxKufgFpbOr3JpyI/ +gCczWw63igxdBzcIy2zSekciRDXFzMwujt0q7bd9Zg1fYVEiVRvjRuPjPdA1Yprb +rxTIW6HMiRvhMCb8oJsfgadHHwTrozmSBp+Z07/T6k9QnBn+locePGX2oxgkg4YQ +51Q+qDp2JE+BIcXjDwL4k5RHILv+1A7TaLndxHqEguNTVHnd25zS8gebLra8Pu2F +be8lEfKXGkJh90qX6IuxEAf6ZYGyojnP9zz/GPvG8VqLWeICrHuS0E4UT1lF9gxe +KF+w6D9Fz8+vm2/7hNN3WpVvrJSEnu68wEqPSpP4RCHiMUVhUE4Q2OM1fEwZtN4F +v6MGn8i1zeQf1xcGDXqVdFUNaBr8EBtiZJ1t4JWgw5QHVw0U5r0F+7if5t+L4sbn +fpb2U8WANFAoWPASUHEXMLrmeGO89LKtmyuy/uE5jF66CyCU3nuDuP/jVo23Eek7 +jPKxwV2dpAtMK9myGPW1n0sCAwEAAaNjMGEwHQYDVR0OBBYEFFLYiDrIn3hm7Ynz +ezhwlMkCAjbQMA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAUUtiIOsifeGbt +ifN7OHCUyQICNtAwDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3DQEBCwUAA4ICAQAL +e3KHwGCmSUyIWOYdiPcUZEim2FgKDk8TNd81HdTtBjHIgT5q1d07GjLukD0R0i70 +jsNjLiNmsGe+b7bAEzlgqqI0JZN1Ut6nna0Oh4lScWoWPBkdg/iaKWW+9D+a2fDz +WochcYBNy+A4mz+7+uAwTc+G02UQGRjRlwKxK3JCaKygvU5a2hi/a5iB0P2avl4V +SM0RFbnAKVy06Ij3Pjaut2L9HmLecHgQHEhb2rykOLpn7VU+Xlff1ANATIGk0k9j +pwlCCRT8AKnCgHNPLsBA2RF7SOp6AsDT6ygBJlh0wcBzIm2Tlf05fbsq4/aC4yyX +X04fkZT6/iyj2HYauE2yOE+b+h1IYHkm4vP9qdCa6HCPSXrW5b0KDtst842/6+Ok +fcvHlXHo2qN8xcL4dJIEG4aspCJTQLas/kx2z/uUMsA1n3Y/buWQbqCmJqK4LL7R +K4X9p2jIugErsWx0Hbhzlefut8cl8ABMALJ+tguLHPPAUJ4lueAI3jZm/zel0btU +ZCzJJ7VLkn5l/9Mt4blOvH+kQSGQQXemOR/qnuOf0GZvBeyqdn6/axag67XH/JJU +LysRJyU3eExRarDzzFhdFPFqSBX/wge2sY0PjlxQRrM9vwGYT7JZVEc+NHt4bVaT +LnPqZih4zR0Uv6CPLy64Lo7yFIrM6bV8+2ydDKXhlg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIENjCCAx6gAwIBAgIBATANBgkqhkiG9w0BAQUFADBvMQswCQYDVQQGEwJTRTEU +MBIGA1UEChMLQWRkVHJ1c3QgQUIxJjAkBgNVBAsTHUFkZFRydXN0IEV4dGVybmFs +IFRUUCBOZXR3b3JrMSIwIAYDVQQDExlBZGRUcnVzdCBFeHRlcm5hbCBDQSBSb290 +MB4XDTAwMDUzMDEwNDgzOFoXDTIwMDUzMDEwNDgzOFowbzELMAkGA1UEBhMCU0Ux +FDASBgNVBAoTC0FkZFRydXN0IEFCMSYwJAYDVQQLEx1BZGRUcnVzdCBFeHRlcm5h +bCBUVFAgTmV0d29yazEiMCAGA1UEAxMZQWRkVHJ1c3QgRXh0ZXJuYWwgQ0EgUm9v +dDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALf3GjPm8gAELTngTlvt +H7xsD821+iO2zt6bETOXpClMfZOfvUq8k+0DGuOPz+VtUFrWlymUWoCwSXrbLpX9 +uMq/NzgtHj6RQa1wVsfwTz/oMp50ysiQVOnGXw94nZpAPA6sYapeFI+eh6FqUNzX +mk6vBbOmcZSccbNQYArHE504B4YCqOmoaSYYkKtMsE8jqzpPhNjfzp/haW+710LX +a0Tkx63ubUFfclpxCDezeWWkWaCUN/cALw3CknLa0Dhy2xSoRcRdKn23tNbE7qzN +E0S3ySvdQwAl+mG5aWpYIxG3pzOPVnVZ9c0p10a3CitlttNCbxWyuHv77+ldU9U0 +WicCAwEAAaOB3DCB2TAdBgNVHQ4EFgQUrb2YejS0Jvf6xCZU7wO94CTLVBowCwYD +VR0PBAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wgZkGA1UdIwSBkTCBjoAUrb2YejS0 +Jvf6xCZU7wO94CTLVBqhc6RxMG8xCzAJBgNVBAYTAlNFMRQwEgYDVQQKEwtBZGRU +cnVzdCBBQjEmMCQGA1UECxMdQWRkVHJ1c3QgRXh0ZXJuYWwgVFRQIE5ldHdvcmsx +IjAgBgNVBAMTGUFkZFRydXN0IEV4dGVybmFsIENBIFJvb3SCAQEwDQYJKoZIhvcN +AQEFBQADggEBALCb4IUlwtYj4g+WBpKdQZic2YR5gdkeWxQHIzZlj7DYd7usQWxH +YINRsPkyPef89iYTx4AWpb9a/IfPeHmJIZriTAcKhjW88t5RxNKWt9x+Tu5w/Rw5 +6wwCURQtjr0W4MHfRnXnJK3s9EK0hZNwEGe6nQY1ShjTK3rMUUKhemPR5ruhxSvC +Nr4TDea9Y355e6cJDUCrat2PisP29owaQgVR1EX1n6diIWgVIEM8med8vSTYqZEX +c4g/VhsxOBi0cQ+azcgOno4uG+GMmIPLHzHxREzGBHNJdmAPx/i9F4BrLunMTA5a +mnkPIAou1Z5jJh5VkpTYghdae9C8x49OhgQ= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEGDCCAwCgAwIBAgIBATANBgkqhkiG9w0BAQUFADBlMQswCQYDVQQGEwJTRTEU +MBIGA1UEChMLQWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFkZFRydXN0IFRUUCBOZXR3 +b3JrMSEwHwYDVQQDExhBZGRUcnVzdCBDbGFzcyAxIENBIFJvb3QwHhcNMDAwNTMw +MTAzODMxWhcNMjAwNTMwMTAzODMxWjBlMQswCQYDVQQGEwJTRTEUMBIGA1UEChML +QWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFkZFRydXN0IFRUUCBOZXR3b3JrMSEwHwYD +VQQDExhBZGRUcnVzdCBDbGFzcyAxIENBIFJvb3QwggEiMA0GCSqGSIb3DQEBAQUA +A4IBDwAwggEKAoIBAQCWltQhSWDia+hBBwzexODcEyPNwTXH+9ZOEQpnXvUGW2ul +CDtbKRY654eyNAbFvAWlA3yCyykQruGIgb3WntP+LVbBFc7jJp0VLhD7Bo8wBN6n +tGO0/7Gcrjyvd7ZWxbWroulpOj0OM3kyP3CCkplhbY0wCI9xP6ZIVxn4JdxLZlyl +dI+Yrsj5wAYi56xz36Uu+1LcsRVlIPo1Zmne3yzxbrww2ywkEtvrNTVokMsAsJch +PXQhI2U0K7t4WaPW4XY5mqRJjox0r26kmqPZm9I4XJuiGMx1I4S+6+JNM3GOGvDC ++Mcdoq0Dlyz4zyXG9rgkMbFjXZJ/Y/AlyVMuH79NAgMBAAGjgdIwgc8wHQYDVR0O +BBYEFJWxtPCUtr3H2tERCSG+wa9J/RB7MAsGA1UdDwQEAwIBBjAPBgNVHRMBAf8E +BTADAQH/MIGPBgNVHSMEgYcwgYSAFJWxtPCUtr3H2tERCSG+wa9J/RB7oWmkZzBl +MQswCQYDVQQGEwJTRTEUMBIGA1UEChMLQWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFk +ZFRydXN0IFRUUCBOZXR3b3JrMSEwHwYDVQQDExhBZGRUcnVzdCBDbGFzcyAxIENB +IFJvb3SCAQEwDQYJKoZIhvcNAQEFBQADggEBACxtZBsfzQ3duQH6lmM0MkhHma6X +7f1yFqZzR1r0693p9db7RcwpiURdv0Y5PejuvE1Uhh4dbOMXJ0PhiVYrqW9yTkkz +43J8KiOavD7/KCrto/8cI7pDVwlnTUtiBi34/2ydYB7YHEt9tTEv2dB8Xfjea4MY +eDdXL+gzB2ffHsdrKpV2ro9Xo/D0UrSpUwjP4E/TelOL/bscVjby/rK25Xa71SJl +pz/+0WatC7xrmYbvP33zGDLKe8bjq2RGlfgmadlVg3sslgf/WSxEo8bl6ancoWOA +WiFeIc9TVPC6b4nbqKqVz4vjccweGyBECMB6tkD9xOQ14R0WHNC8K47Wcdk= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEFTCCAv2gAwIBAgIBATANBgkqhkiG9w0BAQUFADBkMQswCQYDVQQGEwJTRTEU +MBIGA1UEChMLQWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFkZFRydXN0IFRUUCBOZXR3 +b3JrMSAwHgYDVQQDExdBZGRUcnVzdCBQdWJsaWMgQ0EgUm9vdDAeFw0wMDA1MzAx +MDQxNTBaFw0yMDA1MzAxMDQxNTBaMGQxCzAJBgNVBAYTAlNFMRQwEgYDVQQKEwtB +ZGRUcnVzdCBBQjEdMBsGA1UECxMUQWRkVHJ1c3QgVFRQIE5ldHdvcmsxIDAeBgNV +BAMTF0FkZFRydXN0IFB1YmxpYyBDQSBSb290MIIBIjANBgkqhkiG9w0BAQEFAAOC +AQ8AMIIBCgKCAQEA6Rowj4OIFMEg2Dybjxt+A3S72mnTRqX4jsIMEZBRpS9mVEBV +6tsfSlbunyNu9DnLoblv8n75XYcmYZ4c+OLspoH4IcUkzBEMP9smcnrHAZcHF/nX +GCwwfQ56HmIexkvA/X1id9NEHif2P0tEs7c42TkfYNVRknMDtABp4/MUTu7R3AnP +dzRGULD4EfL+OHn3Bzn+UZKXC1sIXzSGAa2Il+tmzV7R/9x98oTaunet3IAIx6eH +1lWfl2royBFkuucZKT8Rs3iQhCBSWxHveNCD9tVIkNAwHM+A+WD+eeSI8t0A65RF +62WUaUC6wNW0uLp9BBGo6zEFlpROWCGOn9Bg/QIDAQABo4HRMIHOMB0GA1UdDgQW +BBSBPjfYkrAfd59ctKtzquf2NGAv+jALBgNVHQ8EBAMCAQYwDwYDVR0TAQH/BAUw +AwEB/zCBjgYDVR0jBIGGMIGDgBSBPjfYkrAfd59ctKtzquf2NGAv+qFopGYwZDEL +MAkGA1UEBhMCU0UxFDASBgNVBAoTC0FkZFRydXN0IEFCMR0wGwYDVQQLExRBZGRU +cnVzdCBUVFAgTmV0d29yazEgMB4GA1UEAxMXQWRkVHJ1c3QgUHVibGljIENBIFJv +b3SCAQEwDQYJKoZIhvcNAQEFBQADggEBAAP3FUr4JNojVhaTdt02KLmuG7jD8WS6 +IBh4lSknVwW8fCr0uVFV2ocC3g8WFzH4qnkuCRO7r7IgGRLlk/lL+YPoRNWyQSW/ +iHVv/xD8SlTQX/D67zZzfRs2RcYhbbQVuE7PnFylPVoAjgbjPGsye/Kf8Lb93/Ao +GEjwxrzQvzSAlsJKsW2Ox5BF3i9nrEUEo3rcVZLJR2bYGozH7ZxOmuASu7VqTITh +4SINhwBk/ox9Yjllpu9CtoAlEmEBqCQTcAARJl/6NVDFSMwGR+gn2HCNX2TmoUQm +XiLsks3/QppEIW1cxeMiHV9HEufOX1362KqxMy3ZdvJOOjMMK7MtkAY= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEHjCCAwagAwIBAgIBATANBgkqhkiG9w0BAQUFADBnMQswCQYDVQQGEwJTRTEU +MBIGA1UEChMLQWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFkZFRydXN0IFRUUCBOZXR3 +b3JrMSMwIQYDVQQDExpBZGRUcnVzdCBRdWFsaWZpZWQgQ0EgUm9vdDAeFw0wMDA1 +MzAxMDQ0NTBaFw0yMDA1MzAxMDQ0NTBaMGcxCzAJBgNVBAYTAlNFMRQwEgYDVQQK +EwtBZGRUcnVzdCBBQjEdMBsGA1UECxMUQWRkVHJ1c3QgVFRQIE5ldHdvcmsxIzAh +BgNVBAMTGkFkZFRydXN0IFF1YWxpZmllZCBDQSBSb290MIIBIjANBgkqhkiG9w0B +AQEFAAOCAQ8AMIIBCgKCAQEA5B6a/twJWoekn0e+EV+vhDTbYjx5eLfpMLXsDBwq +xBb/4Oxx64r1EW7tTw2R0hIYLUkVAcKkIhPHEWT/IhKauY5cLwjPcWqzZwFZ8V1G +87B4pfYOQnrjfxvM0PC3KP0q6p6zsLkEqv32x7SxuCqg+1jxGaBvcCV+PmlKfw8i +2O+tCBGaKZnhqkRFmhJePp1tUvznoD1oL/BLcHwTOK28FSXx1s6rosAx1i+f4P8U +WfyEk9mHfExUE+uf0S0R+Bg6Ot4l2ffTQO2kBhLEO+GRwVY18BTcZTYJbqukB8c1 +0cIDMzZbdSZtQvESa0NvS3GU+jQd7RNuyoB/mC9suWXY6QIDAQABo4HUMIHRMB0G +A1UdDgQWBBQ5lYtii1zJ1IC6WA+XPxUIQ8yYpzALBgNVHQ8EBAMCAQYwDwYDVR0T +AQH/BAUwAwEB/zCBkQYDVR0jBIGJMIGGgBQ5lYtii1zJ1IC6WA+XPxUIQ8yYp6Fr +pGkwZzELMAkGA1UEBhMCU0UxFDASBgNVBAoTC0FkZFRydXN0IEFCMR0wGwYDVQQL +ExRBZGRUcnVzdCBUVFAgTmV0d29yazEjMCEGA1UEAxMaQWRkVHJ1c3QgUXVhbGlm +aWVkIENBIFJvb3SCAQEwDQYJKoZIhvcNAQEFBQADggEBABmrder4i2VhlRO6aQTv +hsoToMeqT2QbPxj2qC0sVY8FtzDqQmodwCVRLae/DLPt7wh/bDxGGuoYQ992zPlm +hpwsaPXpF/gxsxjE1kh9I0xowX67ARRvxdlu3rsEQmr49lx95dr6h+sNNVJn0J6X +dgWTP5XHAeZpVTh/EGGZyeNfpso+gmNIquIISD6q8rKFYqa0p9m9N5xotS1WfbC3 +P6CxB9bpT9zeRXEwMn8bLgn5v1Kh7sKAPgZcLlVAwRv1cEWw3F369nJad9Jjzc9Y +iQBCYz95OdBEsIJuQRno3eDBiFrRHnGTHyQwdOUeqN48Jzd/g66ed8/wMLH/S5no +xqE= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDTDCCAjSgAwIBAgIId3cGJyapsXwwDQYJKoZIhvcNAQELBQAwRDELMAkGA1UE +BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZpcm1UcnVz +dCBDb21tZXJjaWFsMB4XDTEwMDEyOTE0MDYwNloXDTMwMTIzMTE0MDYwNlowRDEL +MAkGA1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZp +cm1UcnVzdCBDb21tZXJjaWFsMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEA9htPZwcroRX1BiLLHwGy43NFBkRJLLtJJRTWzsO3qyxPxkEylFf6EqdbDuKP +Hx6GGaeqtS25Xw2Kwq+FNXkyLbscYjfysVtKPcrNcV/pQr6U6Mje+SJIZMblq8Yr +ba0F8PrVC8+a5fBQpIs7R6UjW3p6+DM/uO+Zl+MgwdYoic+U+7lF7eNAFxHUdPAL +MeIrJmqbTFeurCA+ukV6BfO9m2kVrn1OIGPENXY6BwLJN/3HR+7o8XYdcxXyl6S1 +yHp52UKqK39c/s4mT6NmgTWvRLpUHhwwMmWd5jyTXlBOeuM61G7MGvv50jeuJCqr +VwMiKA1JdX+3KNp1v47j3A55MQIDAQABo0IwQDAdBgNVHQ4EFgQUnZPGU4teyq8/ +nx4P5ZmVvCT2lI8wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwDQYJ +KoZIhvcNAQELBQADggEBAFis9AQOzcAN/wr91LoWXym9e2iZWEnStB03TX8nfUYG +XUPGhi4+c7ImfU+TqbbEKpqrIZcUsd6M06uJFdhrJNTxFq7YpFzUf1GO7RgBsZNj +vbz4YYCanrHOQnDiqX0GJX0nof5v7LMeJNrjS1UaADs1tDvZ110w/YETifLCBivt +Z8SOyUOyXGsViQK8YvxO8rUzqrJv0wqiUOP2O+guRMLbZjipM1ZI8W0bM40NjD9g +N53Tym1+NH4Nn3J2ixufcv1SNUFFApYvHLKac0khsUlHRUe072o0EclNmsxZt9YC +nlpOZbWUrhvfKbAW8b8Angc6F2S1BLUjIZkKlTuXfO8= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDTDCCAjSgAwIBAgIIfE8EORzUmS0wDQYJKoZIhvcNAQEFBQAwRDELMAkGA1UE +BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZpcm1UcnVz +dCBOZXR3b3JraW5nMB4XDTEwMDEyOTE0MDgyNFoXDTMwMTIzMTE0MDgyNFowRDEL +MAkGA1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZp +cm1UcnVzdCBOZXR3b3JraW5nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEAtITMMxcua5Rsa2FSoOujz3mUTOWUgJnLVWREZY9nZOIG41w3SfYvm4SEHi3y +YJ0wTsyEheIszx6e/jarM3c1RNg1lho9Nuh6DtjVR6FqaYvZ/Ls6rnla1fTWcbua +kCNrmreIdIcMHl+5ni36q1Mr3Lt2PpNMCAiMHqIjHNRqrSK6mQEubWXLviRmVSRL +QESxG9fhwoXA3hA/Pe24/PHxI1Pcv2WXb9n5QHGNfb2V1M6+oF4nI979ptAmDgAp +6zxG8D1gvz9Q0twmQVGeFDdCBKNwV6gbh+0t+nvujArjqWaJGctB+d1ENmHP4ndG +yH329JKBNv3bNPFyfvMMFr20FQIDAQABo0IwQDAdBgNVHQ4EFgQUBx/S55zawm6i +QLSwelAQUHTEyL0wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwDQYJ +KoZIhvcNAQEFBQADggEBAIlXshZ6qML91tmbmzTCnLQyFE2npN/svqe++EPbkTfO +tDIuUFUaNU52Q3Eg75N3ThVwLofDwR1t3Mu1J9QsVtFSUzpE0nPIxBsFZVpikpzu +QY0x2+c06lkh1QF612S4ZDnNye2v7UsDSKegmQGA3GWjNq5lWUhPgkvIZfFXHeVZ +Lgo/bNjR9eUJtGxUAArgFU2HdW23WJZa3W3SAKD0m0i+wzekujbgfIeFlxoVot4u +olu9rxj5kFDNcFn4J2dHy8egBzp90SxdbBk6ZrV9/ZFvgrG+CJPbFEfxojfHRZ48 +x3evZKiT3/Zpg4Jg8klCNO1aAFSFHBY2kgxc+qatv9s= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFRjCCAy6gAwIBAgIIbYwURrGmCu4wDQYJKoZIhvcNAQEMBQAwQTELMAkGA1UE +BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MRwwGgYDVQQDDBNBZmZpcm1UcnVz +dCBQcmVtaXVtMB4XDTEwMDEyOTE0MTAzNloXDTQwMTIzMTE0MTAzNlowQTELMAkG +A1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MRwwGgYDVQQDDBNBZmZpcm1U +cnVzdCBQcmVtaXVtMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAxBLf +qV/+Qd3d9Z+K4/as4Tx4mrzY8H96oDMq3I0gW64tb+eT2TZwamjPjlGjhVtnBKAQ +JG9dKILBl1fYSCkTtuG+kU3fhQxTGJoeJKJPj/CihQvL9Cl/0qRY7iZNyaqoe5rZ ++jjeRFcV5fiMyNlI4g0WJx0eyIOFJbe6qlVBzAMiSy2RjYvmia9mx+n/K+k8rNrS +s8PhaJyJ+HoAVt70VZVs+7pk3WKL3wt3MutizCaam7uqYoNMtAZ6MMgpv+0GTZe5 +HMQxK9VfvFMSF5yZVylmd2EhMQcuJUmdGPLu8ytxjLW6OQdJd/zvLpKQBY0tL3d7 +70O/Nbua2Plzpyzy0FfuKE4mX4+QaAkvuPjcBukumj5Rp9EixAqnOEhss/n/fauG +V+O61oV4d7pD6kh/9ti+I20ev9E2bFhc8e6kGVQa9QPSdubhjL08s9NIS+LI+H+S +qHZGnEJlPqQewQcDWkYtuJfzt9WyVSHvutxMAJf7FJUnM7/oQ0dG0giZFmA7mn7S +5u046uwBHjxIVkkJx0w3AJ6IDsBz4W9m6XJHMD4Q5QsDyZpCAGzFlH5hxIrff4Ia +C1nEWTJ3s7xgaVY5/bQGeyzWZDbZvUjthB9+pSKPKrhC9IK31FOQeE4tGv2Bb0TX +OwF0lkLgAOIua+rF7nKsu7/+6qqo+Nz2snmKtmcCAwEAAaNCMEAwHQYDVR0OBBYE +FJ3AZ6YMItkm9UWrpmVSESfYRaxjMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/ +BAQDAgEGMA0GCSqGSIb3DQEBDAUAA4ICAQCzV00QYk465KzquByvMiPIs0laUZx2 +KI15qldGF9X1Uva3ROgIRL8YhNILgM3FEv0AVQVhh0HctSSePMTYyPtwni94loMg +Nt58D2kTiKV1NpgIpsbfrM7jWNa3Pt668+s0QNiigfV4Py/VpfzZotReBA4Xrf5B +8OWycvpEgjNC6C1Y91aMYj+6QrCcDFx+LmUmXFNPALJ4fqENmS2NuB2OosSw/WDQ +MKSOyARiqcTtNd56l+0OOF6SL5Nwpamcb6d9Ex1+xghIsV5n61EIJenmJWtSKZGc +0jlzCFfemQa0W50QBuHCAKi4HEoCChTQwUHK+4w1IX2COPKpVJEZNZOUbWo6xbLQ +u4mGk+ibyQ86p3q4ofB4Rvr8Ny/lioTz3/4E2aFooC8k4gmVBtWVyuEklut89pMF +u+1z6S3RdTnX5yTb2E5fQ4+e0BQ5v1VwSJlXMbSc7kqYA5YwH2AG7hsj/oFgIxpH +YoWlzBk0gG+zrBrjn/B7SK3VAdlntqlyk+otZrWyuOQ9PLLvTIzq6we/qzWaVYa8 +GKa1qF60g2xraUDTn9zxw2lrueFtCfTxqlB2Cnp9ehehVZZCmTEJ3WARjQUwfuaO +RtGdFNrHF+QFlozEJLUbzxQHskD4o55BhrwE0GuWyCqANP2/7waj3VjFhT0+j/6e +KeC2uAloGRwYQw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIB/jCCAYWgAwIBAgIIdJclisc/elQwCgYIKoZIzj0EAwMwRTELMAkGA1UEBhMC +VVMxFDASBgNVBAoMC0FmZmlybVRydXN0MSAwHgYDVQQDDBdBZmZpcm1UcnVzdCBQ +cmVtaXVtIEVDQzAeFw0xMDAxMjkxNDIwMjRaFw00MDEyMzExNDIwMjRaMEUxCzAJ +BgNVBAYTAlVTMRQwEgYDVQQKDAtBZmZpcm1UcnVzdDEgMB4GA1UEAwwXQWZmaXJt +VHJ1c3QgUHJlbWl1bSBFQ0MwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQNMF4bFZ0D +0KF5Nbc6PJJ6yhUczWLznCZcBz3lVPqj1swS6vQUX+iOGasvLkjmrBhDeKzQN8O9 +ss0s5kfiGuZjuD0uL3jET9v0D6RoTFVya5UdThhClXjMNzyR4ptlKymjQjBAMB0G +A1UdDgQWBBSaryl6wBE1NSZRMADDav5A1a7WPDAPBgNVHRMBAf8EBTADAQH/MA4G +A1UdDwEB/wQEAwIBBjAKBggqhkjOPQQDAwNnADBkAjAXCfOHiFBar8jAQr9HX/Vs +aobgxCd05DhT1wV/GzTjxi+zygk8N53X57hG8f2h4nECMEJZh0PUUd+60wkyWs6I +flc9nF9Ca/UHLbXwgpP5WW+uZPpY5Yse42O+tYHNbwKMeQ== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDoDCCAoigAwIBAgIBMTANBgkqhkiG9w0BAQUFADBDMQswCQYDVQQGEwJKUDEc +MBoGA1UEChMTSmFwYW5lc2UgR292ZXJubWVudDEWMBQGA1UECxMNQXBwbGljYXRp +b25DQTAeFw0wNzEyMTIxNTAwMDBaFw0xNzEyMTIxNTAwMDBaMEMxCzAJBgNVBAYT +AkpQMRwwGgYDVQQKExNKYXBhbmVzZSBHb3Zlcm5tZW50MRYwFAYDVQQLEw1BcHBs +aWNhdGlvbkNBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAp23gdE6H +j6UG3mii24aZS2QNcfAKBZuOquHMLtJqO8F6tJdhjYq+xpqcBrSGUeQ3DnR4fl+K +f5Sk10cI/VBaVuRorChzoHvpfxiSQE8tnfWuREhzNgaeZCw7NCPbXCbkcXmP1G55 +IrmTwcrNwVbtiGrXoDkhBFcsovW8R0FPXjQilbUfKW1eSvNNcr5BViCH/OlQR9cw +FO5cjFW6WY2H/CPek9AEjP3vbb3QesmlOmpyM8ZKDQUXKi17safY1vC+9D/qDiht +QWEjdnjDuGWk81quzMKq2edY3rZ+nYVunyoKb58DKTCXKB28t89UKU5RMfkntigm +/qJj5kEW8DOYRwIDAQABo4GeMIGbMB0GA1UdDgQWBBRUWssmP3HMlEYNllPqa0jQ +k/5CdTAOBgNVHQ8BAf8EBAMCAQYwWQYDVR0RBFIwUKROMEwxCzAJBgNVBAYTAkpQ +MRgwFgYDVQQKDA/ml6XmnKzlm73mlL/lupwxIzAhBgNVBAsMGuOCouODl+ODquOC +seODvOOCt+ODp+ODs0NBMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEFBQAD +ggEBADlqRHZ3ODrso2dGD/mLBqj7apAxzn7s2tGJfHrrLgy9mTLnsCTWw//1sogJ +hyzjVOGjprIIC8CFqMjSnHH2HZ9g/DgzE+Ge3Atf2hZQKXsvcJEPmbo0NI2VdMV+ +eKlmXb3KIXdCEKxmJj3ekav9FfBv7WxfEPjzFvYDio+nEhEMy/0/ecGc/WLuo89U +DNErXxc+4z6/wCs+CZv+iKZ+tJIX/COUgb1up8WMwusRRdv4QcmWdupwX3kSa+Sj +B1oF7ydJzyGfikwJcGapJsErEU4z0g781mzSDjJkaP+tBXhfAx2o45CsJOAPQKdL +rosot4LKGAfmt1t06SAZf7IbiVQ= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDdzCCAl+gAwIBAgIIXDPLYixfszIwDQYJKoZIhvcNAQELBQAwPDEeMBwGA1UE +AwwVQXRvcyBUcnVzdGVkUm9vdCAyMDExMQ0wCwYDVQQKDARBdG9zMQswCQYDVQQG +EwJERTAeFw0xMTA3MDcxNDU4MzBaFw0zMDEyMzEyMzU5NTlaMDwxHjAcBgNVBAMM +FUF0b3MgVHJ1c3RlZFJvb3QgMjAxMTENMAsGA1UECgwEQXRvczELMAkGA1UEBhMC +REUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCVhTuXbyo7LjvPpvMp +Nb7PGKw+qtn4TaA+Gke5vJrf8v7MPkfoepbCJI419KkM/IL9bcFyYie96mvr54rM +VD6QUM+A1JX76LWC1BTFtqlVJVfbsVD2sGBkWXppzwO3bw2+yj5vdHLqqjAqc2K+ +SZFhyBH+DgMq92og3AIVDV4VavzjgsG1xZ1kCWyjWZgHJ8cblithdHFsQ/H3NYkQ +4J7sVaE3IqKHBAUsR320HLliKWYoyrfhk/WklAOZuXCFteZI6o1Q/NnezG8HDt0L +cp2AMBYHlT8oDv3FdU9T1nSatCQujgKRz3bFmx5VdJx4IbHwLfELn8LVlhgf8FQi +eowHAgMBAAGjfTB7MB0GA1UdDgQWBBSnpQaxLKYJYO7Rl+lwrrw7GWzbITAPBgNV +HRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFKelBrEspglg7tGX6XCuvDsZbNshMBgG +A1UdIAQRMA8wDQYLKwYBBAGwLQMEAQEwDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3 +DQEBCwUAA4IBAQAmdzTblEiGKkGdLD4GkGDEjKwLVLgfuXvTBznk+j57sj1O7Z8j +vZfza1zv7v1Apt+hk6EKhqzvINB5Ab149xnYJDE0BAGmuhWawyfc2E8PzBhj/5kP +DpFrdRbhIfzYJsdHt6bPWHJxfrrhTZVHO8mvbaG0weyJ9rQPOLXiZNwlz6bb65pc +maHFCN795trV1lpFDMS3wrUU77QR/w4VtfX128a961qn8FYiqTxlVMYVqL2Gns2D +lmh6cYGJ4Qvh6hEbaAjMaZ7snkGeRDImeuKHCnE96+RapNLbxc3G3mB/ufNPRJLv +KrcYPqcZ2Qt9sTdBQrC6YB3y/gkRsPCHe6ed +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIGFDCCA/ygAwIBAgIIU+w77vuySF8wDQYJKoZIhvcNAQEFBQAwUTELMAkGA1UE +BhMCRVMxQjBABgNVBAMMOUF1dG9yaWRhZCBkZSBDZXJ0aWZpY2FjaW9uIEZpcm1h +cHJvZmVzaW9uYWwgQ0lGIEE2MjYzNDA2ODAeFw0wOTA1MjAwODM4MTVaFw0zMDEy +MzEwODM4MTVaMFExCzAJBgNVBAYTAkVTMUIwQAYDVQQDDDlBdXRvcmlkYWQgZGUg +Q2VydGlmaWNhY2lvbiBGaXJtYXByb2Zlc2lvbmFsIENJRiBBNjI2MzQwNjgwggIi +MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDKlmuO6vj78aI14H9M2uDDUtd9 +thDIAl6zQyrET2qyyhxdKJp4ERppWVevtSBC5IsP5t9bpgOSL/UR5GLXMnE42QQM +cas9UX4PB99jBVzpv5RvwSmCwLTaUbDBPLutN0pcyvFLNg4kq7/DhHf9qFD0sefG +L9ItWY16Ck6WaVICqjaY7Pz6FIMMNx/Jkjd/14Et5cS54D40/mf0PmbR0/RAz15i +NA9wBj4gGFrO93IbJWyTdBSTo3OxDqqHECNZXyAFGUftaI6SEspd/NYrspI8IM/h +X68gvqB2f3bl7BqGYTM+53u0P6APjqK5am+5hyZvQWyIplD9amML9ZMWGxmPsu2b +m8mQ9QEM3xk9Dz44I8kvjwzRAv4bVdZO0I08r0+k8/6vKtMFnXkIoctXMbScyJCy +Z/QYFpM6/EfY0XiWMR+6KwxfXZmtY4laJCB22N/9q06mIqqdXuYnin1oKaPnirja +EbsXLZmdEyRG98Xi2J+Of8ePdG1asuhy9azuJBCtLxTa/y2aRnFHvkLfuwHb9H/T +KI8xWVvTyQKmtFLKbpf7Q8UIJm+K9Lv9nyiqDdVF8xM6HdjAeI9BZzwelGSuewvF +6NkBiDkal4ZkQdU7hwxu+g/GvUgUvzlN1J5Bto+WHWOWk9mVBngxaJ43BjuAiUVh +OSPHG0SjFeUc+JIwuwIDAQABo4HvMIHsMBIGA1UdEwEB/wQIMAYBAf8CAQEwDgYD +VR0PAQH/BAQDAgEGMB0GA1UdDgQWBBRlzeurNR4APn7VdMActHNHDhpkLzCBpgYD +VR0gBIGeMIGbMIGYBgRVHSAAMIGPMC8GCCsGAQUFBwIBFiNodHRwOi8vd3d3LmZp +cm1hcHJvZmVzaW9uYWwuY29tL2NwczBcBggrBgEFBQcCAjBQHk4AUABhAHMAZQBv +ACAAZABlACAAbABhACAAQgBvAG4AYQBuAG8AdgBhACAANAA3ACAAQgBhAHIAYwBl +AGwAbwBuAGEAIAAwADgAMAAxADcwDQYJKoZIhvcNAQEFBQADggIBABd9oPm03cXF +661LJLWhAqvdpYhKsg9VSytXjDvlMd3+xDLx51tkljYyGOylMnfX40S2wBEqgLk9 +am58m9Ot/MPWo+ZkKXzR4Tgegiv/J2Wv+xYVxC5xhOW1//qkR71kMrv2JYSiJ0L1 +ILDCExARzRAVukKQKtJE4ZYm6zFIEv0q2skGz3QeqUvVhyj5eTSSPi5E6PaPT481 +PyWzOdxjKpBrIF/EUhJOlywqrJ2X3kjyo2bbwtKDlaZmp54lD+kLM5FlClrD2VQS +3a/DTg4fJl4N3LON7NWBcN7STyQF82xO9UxJZo3R/9ILJUFI/lGExkKvgATP0H5k +SeTy36LssUzAKh3ntLFlosS88Zj0qnAHY7S42jtM+kAiMFsRpvAFDsYCA0irhpuF +3dvd6qJ2gHN99ZwExEWN57kci57q13XRcrHedUTnQn3iV2t93Jm8PYMo6oCTjcVM +ZcFwgbg4/EMxsvYDNEeyrPsiBsse3RdHHF9mudMaotoRsaS8I8nkvof/uZS2+F0g +StRf571oe2XyFR7SOqkt6dhrJKyXWERHrVkY8SFlcN7ONGCoQPHzPKTDKCOM/icz +Q0CgFzzr6juwcqajuUpLXhZI9LK8yIySxZ2frHI2vDSANGupi5LAuBft7HZT9SQB +jLMi6Et8Vcad+qMUu2WFbm5PEn4KPJ2V +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDdzCCAl+gAwIBAgIEAgAAuTANBgkqhkiG9w0BAQUFADBaMQswCQYDVQQGEwJJ +RTESMBAGA1UEChMJQmFsdGltb3JlMRMwEQYDVQQLEwpDeWJlclRydXN0MSIwIAYD +VQQDExlCYWx0aW1vcmUgQ3liZXJUcnVzdCBSb290MB4XDTAwMDUxMjE4NDYwMFoX +DTI1MDUxMjIzNTkwMFowWjELMAkGA1UEBhMCSUUxEjAQBgNVBAoTCUJhbHRpbW9y +ZTETMBEGA1UECxMKQ3liZXJUcnVzdDEiMCAGA1UEAxMZQmFsdGltb3JlIEN5YmVy +VHJ1c3QgUm9vdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKMEuyKr +mD1X6CZymrV51Cni4eiVgLGw41uOKymaZN+hXe2wCQVt2yguzmKiYv60iNoS6zjr +IZ3AQSsBUnuId9Mcj8e6uYi1agnnc+gRQKfRzMpijS3ljwumUNKoUMMo6vWrJYeK +mpYcqWe4PwzV9/lSEy/CG9VwcPCPwBLKBsua4dnKM3p31vjsufFoREJIE9LAwqSu +XmD+tqYF/LTdB1kC1FkYmGP1pWPgkAx9XbIGevOF6uvUA65ehD5f/xXtabz5OTZy +dc93Uk3zyZAsuT3lySNTPx8kmCFcB5kpvcY67Oduhjprl3RjM71oGDHweI12v/ye +jl0qhqdNkNwnGjkCAwEAAaNFMEMwHQYDVR0OBBYEFOWdWTCCR1jMrPoIVDaGezq1 +BE3wMBIGA1UdEwEB/wQIMAYBAf8CAQMwDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3 +DQEBBQUAA4IBAQCFDF2O5G9RaEIFoN27TyclhAO992T9Ldcw46QQF+vaKSm2eT92 +9hkTI7gQCvlYpNRhcL0EYWoSihfVCr3FvDB81ukMJY2GQE/szKN+OMY3EU/t3Wgx +jkzSswF07r51XgdIGn9w/xZchMB5hbgF/X++ZRGjD8ACtPhSNzkE1akxehi/oCr0 +Epn3o0WC4zxe9Z2etciefC7IpJ5OCBRLbf1wbWsaY71k5h+3zvDyny67G7fyUIhz +ksLi4xaNmjICq44Y3ekQEe5+NauQrz4wlHrQMz2nZQ/1/I6eYs9HRCwBXbsdtTLS +R9I4LtD+gdwyah617jzV/OeBHRnDJELqYzmp +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDUzCCAjugAwIBAgIBATANBgkqhkiG9w0BAQUFADBLMQswCQYDVQQGEwJOTzEd +MBsGA1UECgwUQnV5cGFzcyBBUy05ODMxNjMzMjcxHTAbBgNVBAMMFEJ1eXBhc3Mg +Q2xhc3MgMiBDQSAxMB4XDTA2MTAxMzEwMjUwOVoXDTE2MTAxMzEwMjUwOVowSzEL +MAkGA1UEBhMCTk8xHTAbBgNVBAoMFEJ1eXBhc3MgQVMtOTgzMTYzMzI3MR0wGwYD +VQQDDBRCdXlwYXNzIENsYXNzIDIgQ0EgMTCCASIwDQYJKoZIhvcNAQEBBQADggEP +ADCCAQoCggEBAIs8B0XY9t/mx8q6jUPFR42wWsE425KEHK8T1A9vNkYgxC7McXA0 +ojTTNy7Y3Tp3L8DrKehc0rWpkTSHIln+zNvnma+WwajHQN2lFYxuyHyXA8vmIPLX +l18xoS830r7uvqmtqEyeIWZDO6i88wmjONVZJMHCR3axiFyCO7srpgTXjAePzdVB +HfCuuCkslFJgNJQ72uA40Z0zPhX0kzLFANq1KWYOOngPIVJfAuWSeyXTkh4vFZ2B +5J2O6O+JzhRMVB0cgRJNcKi+EAUXfh/RuFdV7c27UsKwHnjCTTZoy1YmwVLBvXb3 +WNVyfh9EdrsAiR0WnVE1703CVu9r4Iw7DekCAwEAAaNCMEAwDwYDVR0TAQH/BAUw +AwEB/zAdBgNVHQ4EFgQUP42aWYv8e3uco684sDntkHGA1sgwDgYDVR0PAQH/BAQD +AgEGMA0GCSqGSIb3DQEBBQUAA4IBAQAVGn4TirnoB6NLJzKyQJHyIdFkhb5jatLP +gcIV1Xp+DCmsNx4cfHZSldq1fyOhKXdlyTKdqC5Wq2B2zha0jX94wNWZUYN/Xtm+ +DKhQ7SLHrQVMdvvt7h5HZPb3J31cKA9FxVxiXqaakZG3Uxcu3K1gnZZkOb1naLKu +BctN518fV4bVIJwo+28TOPX2EZL2fZleHwzoq0QkKXJAPTZSr4xYkHPB7GEseaHs +h7U/2k3ZIQAw3pDaDtMaSKk+hQsUi4y8QZ5q9w5wwDX3OaJdZtB7WZ+oRxKaJyOk +LY4ng5IgodcVf/EuGO70SH8vf/GhGLWhC5SgYiAynB321O+/TIho +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFWTCCA0GgAwIBAgIBAjANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJOTzEd +MBsGA1UECgwUQnV5cGFzcyBBUy05ODMxNjMzMjcxIDAeBgNVBAMMF0J1eXBhc3Mg +Q2xhc3MgMiBSb290IENBMB4XDTEwMTAyNjA4MzgwM1oXDTQwMTAyNjA4MzgwM1ow +TjELMAkGA1UEBhMCTk8xHTAbBgNVBAoMFEJ1eXBhc3MgQVMtOTgzMTYzMzI3MSAw +HgYDVQQDDBdCdXlwYXNzIENsYXNzIDIgUm9vdCBDQTCCAiIwDQYJKoZIhvcNAQEB +BQADggIPADCCAgoCggIBANfHXvfBB9R3+0Mh9PT1aeTuMgHbo4Yf5FkNuud1g1Lr +6hxhFUi7HQfKjK6w3Jad6sNgkoaCKHOcVgb/S2TwDCo3SbXlzwx87vFKu3MwZfPV +L4O2fuPn9Z6rYPnT8Z2SdIrkHJasW4DptfQxh6NR/Md+oW+OU3fUl8FVM5I+GC91 +1K2GScuVr1QGbNgGE41b/+EmGVnAJLqBcXmQRFBoJJRfuLMR8SlBYaNByyM21cHx +MlAQTn/0hpPshNOOvEu/XAFOBz3cFIqUCqTqc/sLUegTBxj6DvEr0VQVfTzh97QZ +QmdiXnfgolXsttlpF9U6r0TtSsWe5HonfOV116rLJeffawrbD02TTqigzXsu8lkB +arcNuAeBfos4GzjmCleZPe4h6KP1DBbdi+w0jpwqHAAVF41og9JwnxgIzRFo1clr +Us3ERo/ctfPYV3Me6ZQ5BL/T3jjetFPsaRyifsSP5BtwrfKi+fv3FmRmaZ9JUaLi +FRhnBkp/1Wy1TbMz4GHrXb7pmA8y1x1LPC5aAVKRCfLf6o3YBkBjqhHk/sM3nhRS +P/TizPJhk9H9Z2vXUq6/aKtAQ6BXNVN48FP4YUIHZMbXb5tMOA1jrGKvNouicwoN +9SG9dKpN6nIDSdvHXx1iY8f93ZHsM+71bbRuMGjeyNYmsHVee7QHIJihdjK4TWxP +AgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFMmAd+BikoL1Rpzz +uvdMw964o605MA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAgEAU18h +9bqwOlI5LJKwbADJ784g7wbylp7ppHR/ehb8t/W2+xUbP6umwHJdELFx7rxP462s +A20ucS6vxOOto70MEae0/0qyexAQH6dXQbLArvQsWdZHEIjzIVEpMMpghq9Gqx3t +OluwlN5E40EIosHsHdb9T7bWR9AUC8rmyrV7d35BH16Dx7aMOZawP5aBQW9gkOLo ++fsicdl9sz1Gv7SEr5AcD48Saq/v7h56rgJKihcrdv6sVIkkLE8/trKnToyokZf7 +KcZ7XC25y2a2t6hbElGFtQl+Ynhw/qlqYLYdDnkM/crqJIByw5c/8nerQyIKx+u2 +DISCLIBrQYoIwOula9+ZEsuK1V6ADJHgJgg2SMX6OBE1/yWDLfJ6v9r9jv6ly0Us +H8SIU653DtmadsWOLB2jutXsMq7Aqqz30XpN69QH4kj3Io6wpJ9qzo6ysmD0oyLQ +I+uUWnpp3Q+/QFesa1lQ2aOZ4W7+jQF5JyMV3pKdewlNWudLSDBaGOYKbeaP4NK7 +5t98biGCwWg5TbSYWGZizEqQXsP6JwSxeRV0mcy+rSDeJmAc61ZRpqPq5KM/p/9h +3PFaTWwyI0PurKju7koSCTxdccK+efrCh2gdC/1cacwG0Jp9VJkqyTkaGa9LKkPz +Y11aWOIv4x3kqdbQCtCev9eBCfHJxyYNrJgWVqA= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDUzCCAjugAwIBAgIBAjANBgkqhkiG9w0BAQUFADBLMQswCQYDVQQGEwJOTzEd +MBsGA1UECgwUQnV5cGFzcyBBUy05ODMxNjMzMjcxHTAbBgNVBAMMFEJ1eXBhc3Mg +Q2xhc3MgMyBDQSAxMB4XDTA1MDUwOTE0MTMwM1oXDTE1MDUwOTE0MTMwM1owSzEL +MAkGA1UEBhMCTk8xHTAbBgNVBAoMFEJ1eXBhc3MgQVMtOTgzMTYzMzI3MR0wGwYD +VQQDDBRCdXlwYXNzIENsYXNzIDMgQ0EgMTCCASIwDQYJKoZIhvcNAQEBBQADggEP +ADCCAQoCggEBAKSO13TZKWTeXx+HgJHqTjnmGcZEC4DVC69TB4sSveZn8AKxifZg +isRbsELRwCGoy+Gb72RRtqfPFfV0gGgEkKBYouZ0plNTVUhjP5JW3SROjvi6K//z +NIqeKNc0n6wv1g/xpC+9UrJJhW05NfBEMJNGJPO251P7vGGvqaMU+8IXF4Rs4HyI ++MkcVyzwPX6UvCWThOiaAJpFBUJXgPROztmuOfbIUxAMZTpHe2DC1vqRycZxbL2R +hzyRhkmr8w+gbCZ2Xhysm3HljbybIR6c1jh+JIAVMYKWsUnTYjdbiAwKYjT+p0h+ +mbEwi5A3lRyoH6UsjfRVyNvdWQrCrXig9IsCAwEAAaNCMEAwDwYDVR0TAQH/BAUw +AwEB/zAdBgNVHQ4EFgQUOBTmyPCppAP0Tj4io1vy1uCtQHQwDgYDVR0PAQH/BAQD +AgEGMA0GCSqGSIb3DQEBBQUAA4IBAQABZ6OMySU9E2NdFm/soT4JXJEVKirZgCFP +Bdy7pYmrEzMqnji3jG8CcmPHc3ceCQa6Oyh7pEfJYWsICCD8igWKH7y6xsL+z27s +EzNxZy5p+qksP2bAEllNC1QCkoS72xLvg3BweMhT+t/Gxv/ciC8HwEmdMldg0/L2 +mSlf56oBzKwzqBwKu5HEA6BvtjT5htOzdlSY9EqBs1OdTUDs5XcTRa9bqh/YL0yC +e/4qxFi7T/ye/QNlGioOw6UgFpRreaaiErS7GqQjel/wroQk5PMr+4okoyeYZdow +dXb8GZHo2+ubPzK/QJcHJrrM85SFSnonk8+QQtS4Wxam58tAA915 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFWTCCA0GgAwIBAgIBAjANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJOTzEd +MBsGA1UECgwUQnV5cGFzcyBBUy05ODMxNjMzMjcxIDAeBgNVBAMMF0J1eXBhc3Mg +Q2xhc3MgMyBSb290IENBMB4XDTEwMTAyNjA4Mjg1OFoXDTQwMTAyNjA4Mjg1OFow +TjELMAkGA1UEBhMCTk8xHTAbBgNVBAoMFEJ1eXBhc3MgQVMtOTgzMTYzMzI3MSAw +HgYDVQQDDBdCdXlwYXNzIENsYXNzIDMgUm9vdCBDQTCCAiIwDQYJKoZIhvcNAQEB +BQADggIPADCCAgoCggIBAKXaCpUWUOOV8l6ddjEGMnqb8RB2uACatVI2zSRHsJ8Y +ZLya9vrVediQYkwiL944PdbgqOkcLNt4EemOaFEVcsfzM4fkoF0LXOBXByow9c3E +N3coTRiR5r/VUv1xLXA+58bEiuPwKAv0dpihi4dVsjoT/Lc+JzeOIuOoTyrvYLs9 +tznDDgFHmV0ST9tD+leh7fmdvhFHJlsTmKtdFoqwNxxXnUX/iJY2v7vKB3tvh2PX +0DJq1l1sDPGzbjniazEuOQAnFN44wOwZZoYS6J1yFhNkUsepNxz9gjDthBgd9K5c +/3ATAOux9TN6S9ZV+AWNS2mw9bMoNlwUxFFzTWsL8TQH2xc519woe2v1n/MuwU8X +KhDzzMro6/1rqy6any2CbgTUUgGTLT2G/H783+9CHaZr77kgxve9oKeV/afmiSTY +zIw0bOIjL9kSGiG5VZFvC5F5GQytQIgLcOJ60g7YaEi7ghM5EFjp2CoHxhLbWNvS +O1UQRwUVZ2J+GGOmRj8JDlQyXr8NYnon74Do29lLBlo3WiXQCBJ31G8JUJc9yB3D +34xFMFbG02SrZvPAXpacw8Tvw3xrizp5f7NJzz3iiZ+gMEuFuZyUJHmPfWupRWgP +K9Dx2hzLabjKSWJtyNBjYt1gD1iqj6G8BaVmos8bdrKEZLFMOVLAMLrwjEsCsLa3 +AgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEe4zf/lb+74suwv +Tg75JbCOPGvDMA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAgEAACAj +QTUEkMJAYmDv4jVM1z+s4jSQuKFvdvoWFqRINyzpkMLyPPgKn9iB5btb2iUspKdV +cSQy9sgL8rxq+JOssgfCX5/bzMiKqr5qb+FJEMwx14C7u8jYog5kV+qi9cKpMRXS +IGrs/CIBKM+GuIAeqcwRpTzyFrNHnfzSgCHEy9BHcEGhyoMZCCxt8l13nIoUE9Q2 +HJLw5QY33KbmkJs4j1xrG0aGQ0JfPgEHU1RdZX33inOhmlRaHylDFCfChQ+1iHsa +O5S3HWCntZznKWlXWpuTekMwGwPXYshApqr8ZORK15FTAaggiG6cX0S5y2CBNOxv +033aSF/rtJC8LakcC6wc1aJoIIAE1vyxjy+7SjENSoYc6+I2KSb12tjE8nVhz36u +dmNKekBlk4f4HoCMhuWG1o8O/FMsYOgWYRqiPkN7zTlgVGr18okmAWiDSKIz6MkE +kbIRNBE+6tBDGR8Dk5AM/1E9V/RBbuHLoL7ryWPNbczk+DaqaJ3tvV2XcEQNtg41 +3OEMXbugUZTLfhbrES+jkkXITHHZvMmZUldGL1DPvTVp9D0VzgalLA8+9oG6lLvD +u79leNKGef9JOxqDDPDeeOzI8k1MGt6CKfjBWtrt7uYnXuhF0J0cUahoq0Tj0Itq +4/g7u9xN12TyUb7mqqta6THuBrxzvxNiCp/HuZc= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEDzCCAvegAwIBAgIBATANBgkqhkiG9w0BAQUFADBKMQswCQYDVQQGEwJTSzET +MBEGA1UEBxMKQnJhdGlzbGF2YTETMBEGA1UEChMKRGlzaWcgYS5zLjERMA8GA1UE +AxMIQ0EgRGlzaWcwHhcNMDYwMzIyMDEzOTM0WhcNMTYwMzIyMDEzOTM0WjBKMQsw +CQYDVQQGEwJTSzETMBEGA1UEBxMKQnJhdGlzbGF2YTETMBEGA1UEChMKRGlzaWcg +YS5zLjERMA8GA1UEAxMIQ0EgRGlzaWcwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAw +ggEKAoIBAQCS9jHBfYj9mQGp2HvycXXxMcbzdWb6UShGhJd4NLxs/LxFWYgmGErE +Nx+hSkS943EE9UQX4j/8SFhvXJ56CbpRNyIjZkMhsDxkovhqFQ4/61HhVKndBpnX +mjxUizkDPw/Fzsbrg3ICqB9x8y34dQjbYkzo+s7552oftms1grrijxaSfQUMbEYD +XcDtab86wYqg6I7ZuUUohwjstMoVvoLdtUSLLa2GDGhibYVW8qwUYzrG0ZmsNHhW +S8+2rT+MitcE5eN4TPWGqvWP+j1scaMtymfraHtuM6kMgiioTGohQBUgDCZbg8Kp +FhXAJIJdKxatymP2dACw30PEEGBWZ2NFAgMBAAGjgf8wgfwwDwYDVR0TAQH/BAUw +AwEB/zAdBgNVHQ4EFgQUjbJJaJ1yCCW5wCf1UJNWSEZx+Y8wDgYDVR0PAQH/BAQD +AgEGMDYGA1UdEQQvMC2BE2Nhb3BlcmF0b3JAZGlzaWcuc2uGFmh0dHA6Ly93d3cu +ZGlzaWcuc2svY2EwZgYDVR0fBF8wXTAtoCugKYYnaHR0cDovL3d3dy5kaXNpZy5z +ay9jYS9jcmwvY2FfZGlzaWcuY3JsMCygKqAohiZodHRwOi8vY2EuZGlzaWcuc2sv +Y2EvY3JsL2NhX2Rpc2lnLmNybDAaBgNVHSAEEzARMA8GDSuBHpGT5goAAAABAQEw +DQYJKoZIhvcNAQEFBQADggEBAF00dGFMrzvY/59tWDYcPQuBDRIrRhCA/ec8J9B6 +yKm2fnQwM6M6int0wHl5QpNt/7EpFIKrIYwvF/k/Ji/1WcbvgAa3mkkp7M5+cTxq +EEHA9tOasnxakZzArFvITV734VP/Q3f8nktnbNfzg9Gg4H8l37iYC5oyOGwwoPP/ +CBUz91BKez6jPiCp3C9WgArtQVCwyfTssuMmRAAOb54GvCKWU3BlxFAKRmukLyeB +EicTXxChds6KezfqwzlhA5WYOudsiCUI/HloDYd9Yvi0X/vF2Ey9WLw/Q1vUHgFN +PGO+I++MzVpQuGhU+QqZMxEA4Z7CRneC9VkGjCFMhwnN5ag= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFaTCCA1GgAwIBAgIJAMMDmu5QkG4oMA0GCSqGSIb3DQEBBQUAMFIxCzAJBgNV +BAYTAlNLMRMwEQYDVQQHEwpCcmF0aXNsYXZhMRMwEQYDVQQKEwpEaXNpZyBhLnMu +MRkwFwYDVQQDExBDQSBEaXNpZyBSb290IFIxMB4XDTEyMDcxOTA5MDY1NloXDTQy +MDcxOTA5MDY1NlowUjELMAkGA1UEBhMCU0sxEzARBgNVBAcTCkJyYXRpc2xhdmEx +EzARBgNVBAoTCkRpc2lnIGEucy4xGTAXBgNVBAMTEENBIERpc2lnIFJvb3QgUjEw +ggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCqw3j33Jijp1pedxiy3QRk +D2P9m5YJgNXoqqXinCaUOuiZc4yd39ffg/N4T0Dhf9Kn0uXKE5Pn7cZ3Xza1lK/o +OI7bm+V8u8yN63Vz4STN5qctGS7Y1oprFOsIYgrY3LMATcMjfF9DCCMyEtztDK3A +fQ+lekLZWnDZv6fXARz2m6uOt0qGeKAeVjGu74IKgEH3G8muqzIm1Cxr7X1r5OJe +IgpFy4QxTaz+29FHuvlglzmxZcfe+5nkCiKxLU3lSCZpq+Kq8/v8kiky6bM+TR8n +oc2OuRf7JT7JbvN32g0S9l3HuzYQ1VTW8+DiR0jm3hTaYVKvJrT1cU/J19IG32PK +/yHoWQbgCNWEFVP3Q+V8xaCJmGtzxmjOZd69fwX3se72V6FglcXM6pM6vpmumwKj +rckWtc7dXpl4fho5frLABaTAgqWjR56M6ly2vGfb5ipN0gTco65F97yLnByn1tUD +3AjLLhbKXEAz6GfDLuemROoRRRw1ZS0eRWEkG4IupZ0zXWX4Qfkuy5Q/H6MMMSRE +7cderVC6xkGbrPAXZcD4XW9boAo0PO7X6oifmPmvTiT6l7Jkdtqr9O3jw2Dv1fkC +yC2fg69naQanMVXVz0tv/wQFx1isXxYb5dKj6zHbHzMVTdDypVP1y+E9Tmgt2BLd +qvLmTZtJ5cUoobqwWsagtQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1Ud +DwEB/wQEAwIBBjAdBgNVHQ4EFgQUiQq0OJMa5qvum5EY+fU8PjXQ04IwDQYJKoZI +hvcNAQEFBQADggIBADKL9p1Kyb4U5YysOMo6CdQbzoaz3evUuii+Eq5FLAR0rBNR +xVgYZk2C2tXck8An4b58n1KeElb21Zyp9HWc+jcSjxyT7Ff+Bw+r1RL3D65hXlaA +SfX8MPWbTx9BLxyE04nH4toCdu0Jz2zBuByDHBb6lM19oMgY0sidbvW9adRtPTXo +HqJPYNcHKfyyo6SdbhWSVhlMCrDpfNIZTUJG7L399ldb3Zh+pE3McgODWF3vkzpB +emOqfDqo9ayk0d2iLbYq/J8BjuIQscTK5GfbVSUZP/3oNn6z4eGBrxEWi1CXYBmC +AMBrTXO40RMHPuq2MU/wQppt4hF05ZSsjYSVPCGvxdpHyN85YmLLW1AL14FABZyb +7bq2ix4Eb5YgOe2kfSnbSM6C3NQCjR0EMVrHS/BsYVLXtFHCgWzN4funodKSds+x +DzdYpPJScWc/DIh4gInByLUfkmO+p3qKViwaqKactV2zY9ATIKHrkWzQjX2v3wvk +F7mGnjixlAxYjOBVqjtjbZqJYLhkKpLGN/R+Q0O3c+gB53+XD9fyexn9GtePyfqF +a3qdnom2piiZk4hA9z7NUaPK6u95RyG1/jLix8NRb76AdPCkwzryT+lf3xkK8jsT +Q6wxpLPn6/wY1gGp8yqPNg7rtLG8t0zJa7+h89n07eLw4+1knj0vllJPgFOL +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFaTCCA1GgAwIBAgIJAJK4iNuwisFjMA0GCSqGSIb3DQEBCwUAMFIxCzAJBgNV +BAYTAlNLMRMwEQYDVQQHEwpCcmF0aXNsYXZhMRMwEQYDVQQKEwpEaXNpZyBhLnMu +MRkwFwYDVQQDExBDQSBEaXNpZyBSb290IFIyMB4XDTEyMDcxOTA5MTUzMFoXDTQy +MDcxOTA5MTUzMFowUjELMAkGA1UEBhMCU0sxEzARBgNVBAcTCkJyYXRpc2xhdmEx +EzARBgNVBAoTCkRpc2lnIGEucy4xGTAXBgNVBAMTEENBIERpc2lnIFJvb3QgUjIw +ggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCio8QACdaFXS1tFPbCw3Oe +NcJxVX6B+6tGUODBfEl45qt5WDza/3wcn9iXAng+a0EE6UG9vgMsRfYvZNSrXaNH +PWSb6WiaxswbP7q+sos0Ai6YVRn8jG+qX9pMzk0DIaPY0jSTVpbLTAwAFjxfGs3I +x2ymrdMxp7zo5eFm1tL7A7RBZckQrg4FY8aAamkw/dLukO8NJ9+flXP04SXabBbe +QTg06ov80egEFGEtQX6sx3dOy1FU+16SGBsEWmjGycT6txOgmLcRK7fWV8x8nhfR +yyX+hk4kLlYMeE2eARKmK6cBZW58Yh2EhN/qwGu1pSqVg8NTEQxzHQuyRpDRQjrO +QG6Vrf/GlK1ul4SOfW+eioANSW1z4nuSHsPzwfPrLgVv2RvPN3YEyLRa5Beny912 +H9AZdugsBbPWnDTYltxhh5EF5EQIM8HauQhl1K6yNg3ruji6DOWbnuuNZt2Zz9aJ +QfYEkoopKW1rOhzndX0CcQ7zwOe9yxndnWCywmZgtrEE7snmhrmaZkCo5xHtgUUD +i/ZnWejBBhG93c+AAk9lQHhcR1DIm+YfgXvkRKhbhZri3lrVx/k6RGZL5DJUfORs +nLMOPReisjQS1n6yqEm70XooQL6iFh/f5DcfEXP7kAplQ6INfPgGAVUzfbANuPT1 +rqVCV3w2EYx7XsQDnYx5nQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1Ud +DwEB/wQEAwIBBjAdBgNVHQ4EFgQUtZn4r7CU9eMg1gqtzk5WpC5uQu0wDQYJKoZI +hvcNAQELBQADggIBACYGXnDnZTPIgm7ZnBc6G3pmsgH2eDtpXi/q/075KMOYKmFM +tCQSin1tERT3nLXK5ryeJ45MGcipvXrA1zYObYVybqjGom32+nNjf7xueQgcnYqf +GopTpti72TVVsRHFqQOzVju5hJMiXn7B9hJSi+osZ7z+Nkz1uM/Rs0mSO9MpDpkb +lvdhuDvEK7Z4bLQjb/D907JedR+Zlais9trhxTF7+9FGs9K8Z7RiVLoJ92Owk6Ka ++elSLotgEqv89WBW7xBci8QaQtyDW2QOy7W81k/BfDxujRNt+3vrMNDcTa/F1bal +TFtxyegxvug4BkihGuLq0t4SOVga/4AOgnXmt8kHbA7v/zjxmHHEt38OFdAlab0i +nSvtBfZGR6ztwPDUO+Ls7pZbkBNOHlY667DvlruWIxG68kOGdGSVyCh13x01utI3 +gzhTODY7z2zp+WsO0PsE6E9312UBeIYMej4hYvF/Y3EMyZ9E26gnonW+boE+18Dr +G5gPcFw0sorMwIUY6256s/daoQe/qUKS82Ail+QUoQebTnbAjn39pCXHR+3/H3Os +zMOl6W8KjptlwlCFtaOgUxLMVYdh84GuEEZhvUQhuMI9dM9+JDX6HAcOmz0iyu8x +L4ysEr3vQCj8KWefshNPZiTEUxnpHikV7+ZtsH8tZ/3zbBt1RqPlShfppNcL +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFjTCCA3WgAwIBAgIEGErM1jANBgkqhkiG9w0BAQsFADBWMQswCQYDVQQGEwJD +TjEwMC4GA1UECgwnQ2hpbmEgRmluYW5jaWFsIENlcnRpZmljYXRpb24gQXV0aG9y +aXR5MRUwEwYDVQQDDAxDRkNBIEVWIFJPT1QwHhcNMTIwODA4MDMwNzAxWhcNMjkx +MjMxMDMwNzAxWjBWMQswCQYDVQQGEwJDTjEwMC4GA1UECgwnQ2hpbmEgRmluYW5j +aWFsIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MRUwEwYDVQQDDAxDRkNBIEVWIFJP +T1QwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDXXWvNED8fBVnVBU03 +sQ7smCuOFR36k0sXgiFxEFLXUWRwFsJVaU2OFW2fvwwbwuCjZ9YMrM8irq93VCpL +TIpTUnrD7i7es3ElweldPe6hL6P3KjzJIx1qqx2hp/Hz7KDVRM8Vz3IvHWOX6Jn5 +/ZOkVIBMUtRSqy5J35DNuF++P96hyk0g1CXohClTt7GIH//62pCfCqktQT+x8Rgp +7hZZLDRJGqgG16iI0gNyejLi6mhNbiyWZXvKWfry4t3uMCz7zEasxGPrb382KzRz +EpR/38wmnvFyXVBlWY9ps4deMm/DGIq1lY+wejfeWkU7xzbh72fROdOXW3NiGUgt +hxwG+3SYIElz8AXSG7Ggo7cbcNOIabla1jj0Ytwli3i/+Oh+uFzJlU9fpy25IGvP +a931DfSCt/SyZi4QKPaXWnuWFo8BGS1sbn85WAZkgwGDg8NNkt0yxoekN+kWzqot +aK8KgWU6cMGbrU1tVMoqLUuFG7OA5nBFDWteNfB/O7ic5ARwiRIlk9oKmSJgamNg +TnYGmE69g60dWIolhdLHZR4tjsbftsbhf4oEIRUpdPA+nJCdDC7xij5aqgwJHsfV +PKPtl8MeNPo4+QgO48BdK4PRVmrJtqhUUy54Mmc9gn900PvhtgVguXDbjgv5E1hv +cWAQUhC5wUEJ73IfZzF4/5YFjQIDAQABo2MwYTAfBgNVHSMEGDAWgBTj/i39KNAL +tbq2osS/BqoFjJP7LzAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjAd +BgNVHQ4EFgQU4/4t/SjQC7W6tqLEvwaqBYyT+y8wDQYJKoZIhvcNAQELBQADggIB +ACXGumvrh8vegjmWPfBEp2uEcwPenStPuiB/vHiyz5ewG5zz13ku9Ui20vsXiObT +ej/tUxPQ4i9qecsAIyjmHjdXNYmEwnZPNDatZ8POQQaIxffu2Bq41gt/UP+TqhdL +jOztUmCypAbqTuv0axn96/Ua4CUqmtzHQTb3yHQFhDmVOdYLO6Qn+gjYXB74BGBS +ESgoA//vU2YApUo0FmZ8/Qmkrp5nGm9BC2sGE5uPhnEFtC+NiWYzKXZUmhH4J/qy +P5Hgzg0b8zAarb8iXRvTvyUFTeGSGn+ZnzxEk8rUQElsgIfXBDrDMlI1Dlb4pd19 +xIsNER9Tyx6yF7Zod1rg1MvIB671Oi6ON7fQAUtDKXeMOZePglr4UeWJoBjnaH9d +Ci77o0cOPaYjesYBx4/IXr9tgFa+iiS6M+qf4TIRnvHST4D2G0CvOJ4RUHlzEhLN +5mydLIhyPDCBBpEi6lmt2hkuIsKNuYyH4Ga8cyNfIWRjgEj1oDwYPZTISEEdQLpe +/v5WOaHIz16eGWRGENoXkbcFgKyLmZJ956LYBws2J+dIeWCKw9cTXPhyQN9Ky8+Z +AAoACxGV2lZFA4gKn2fQ1XmxqI1AbQ3CekD6819kR5LLU7m7Wc5P/dAVUwHY3+vZ +5nbv0CO7O6l5s9UCKc2Jo5YPSjXnTkLAdc0Hz+Ys63su +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDVTCCAj2gAwIBAgIESTMAATANBgkqhkiG9w0BAQUFADAyMQswCQYDVQQGEwJD +TjEOMAwGA1UEChMFQ05OSUMxEzARBgNVBAMTCkNOTklDIFJPT1QwHhcNMDcwNDE2 +MDcwOTE0WhcNMjcwNDE2MDcwOTE0WjAyMQswCQYDVQQGEwJDTjEOMAwGA1UEChMF +Q05OSUMxEzARBgNVBAMTCkNOTklDIFJPT1QwggEiMA0GCSqGSIb3DQEBAQUAA4IB +DwAwggEKAoIBAQDTNfc/c3et6FtzF8LRb+1VvG7q6KR5smzDo+/hn7E7SIX1mlwh +IhAsxYLO2uOabjfhhyzcuQxauohV3/2q2x8x6gHx3zkBwRP9SFIhxFXf2tizVHa6 +dLG3fdfA6PZZxU3Iva0fFNrfWEQlMhkqx35+jq44sDB7R3IJMfAw28Mbdim7aXZO +V/kbZKKTVrdvmW7bCgScEeOAH8tjlBAKqeFkgjH5jCftppkA9nCTGPihNIaj3XrC +GHn2emU1z5DrvTOTn1OrczvmmzQgLx3vqR1jGqCA2wMv+SYahtKNu6m+UjqHZ0gN +v7Sg2Ca+I19zN38m5pIEo3/PIKe38zrKy5nLAgMBAAGjczBxMBEGCWCGSAGG+EIB +AQQEAwIABzAfBgNVHSMEGDAWgBRl8jGtKvf33VKWCscCwQ7vptU7ETAPBgNVHRMB +Af8EBTADAQH/MAsGA1UdDwQEAwIB/jAdBgNVHQ4EFgQUZfIxrSr3991SlgrHAsEO +76bVOxEwDQYJKoZIhvcNAQEFBQADggEBAEs17szkrr/Dbq2flTtLP1se31cpolnK +OOK5Gv+e5m4y3R6u6jW39ZORTtpC4cMXYFDy0VwmuYK36m3knITnA3kXr5g9lNvH +ugDnuL8BV8F3RTIMO/G0HAiw/VGgod2aHRM2mm23xzy54cXZF/qD1T0VoDy7Hgvi +yJA/qIYM/PmLXoXLT1tLYhFHxUV8BS9BsZ4QaRuZluBVeftOhpm4lNqGOGqTo+fL +buXf6iFViZx9fX+Y9QCJ7uOEwFyWtcVG6kbghVW2G8kS1sHNzYDzAgE8yGnLRUhj +2JTQ7IUOO04RZfSCjKY9ri4ilAnIXOo8gV0WKgOXFlUJ24pBgp5mmxE= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEHTCCAwWgAwIBAgIQToEtioJl4AsC7j41AkblPTANBgkqhkiG9w0BAQUFADCB +gTELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4G +A1UEBxMHU2FsZm9yZDEaMBgGA1UEChMRQ09NT0RPIENBIExpbWl0ZWQxJzAlBgNV +BAMTHkNPTU9ETyBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0wNjEyMDEwMDAw +MDBaFw0yOTEyMzEyMzU5NTlaMIGBMQswCQYDVQQGEwJHQjEbMBkGA1UECBMSR3Jl +YXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHEwdTYWxmb3JkMRowGAYDVQQKExFDT01P +RE8gQ0EgTGltaXRlZDEnMCUGA1UEAxMeQ09NT0RPIENlcnRpZmljYXRpb24gQXV0 +aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0ECLi3LjkRv3 +UcEbVASY06m/weaKXTuH+7uIzg3jLz8GlvCiKVCZrts7oVewdFFxze1CkU1B/qnI +2GqGd0S7WWaXUF601CxwRM/aN5VCaTwwxHGzUvAhTaHYujl8HJ6jJJ3ygxaYqhZ8 +Q5sVW7euNJH+1GImGEaaP+vB+fGQV+useg2L23IwambV4EajcNxo2f8ESIl33rXp ++2dtQem8Ob0y2WIC8bGoPW43nOIv4tOiJovGuFVDiOEjPqXSJDlqR6sA1KGzqSX+ +DT+nHbrTUcELpNqsOO9VUCQFZUaTNE8tja3G1CEZ0o7KBWFxB3NH5YoZEr0ETc5O +nKVIrLsm9wIDAQABo4GOMIGLMB0GA1UdDgQWBBQLWOWLxkwVN6RAqTCpIb5HNlpW +/zAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zBJBgNVHR8EQjBAMD6g +PKA6hjhodHRwOi8vY3JsLmNvbW9kb2NhLmNvbS9DT01PRE9DZXJ0aWZpY2F0aW9u +QXV0aG9yaXR5LmNybDANBgkqhkiG9w0BAQUFAAOCAQEAPpiem/Yb6dc5t3iuHXIY +SdOH5EOC6z/JqvWote9VfCFSZfnVDeFs9D6Mk3ORLgLETgdxb8CPOGEIqB6BCsAv +IC9Bi5HcSEW88cbeunZrM8gALTFGTO3nnc+IlP8zwFboJIYmuNg4ON8qa90SzMc/ +RxdMosIGlgnW2/4/PEZB31jiVg88O8EckzXZOFKs7sjsLjBOlDW0JB9LeGna8gI4 +zJVSk/BwJVmcIGfE7vmLV2H0knZ9P4SNVbfo5azV8fUZVqZa+5Acr5Pr5RzUZ5dd +BA6+C4OmF4O5MBKgxTMVBbkN+8cFduPYSo38NBejxiEovjBFMR7HeL5YYTisO+IB +ZQ== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICiTCCAg+gAwIBAgIQH0evqmIAcFBUTAGem2OZKjAKBggqhkjOPQQDAzCBhTEL +MAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UE +BxMHU2FsZm9yZDEaMBgGA1UEChMRQ09NT0RPIENBIExpbWl0ZWQxKzApBgNVBAMT +IkNPTU9ETyBFQ0MgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDgwMzA2MDAw +MDAwWhcNMzgwMTE4MjM1OTU5WjCBhTELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdy +ZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UEBxMHU2FsZm9yZDEaMBgGA1UEChMRQ09N +T0RPIENBIExpbWl0ZWQxKzApBgNVBAMTIkNPTU9ETyBFQ0MgQ2VydGlmaWNhdGlv +biBBdXRob3JpdHkwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQDR3svdcmCFYX7deSR +FtSrYpn1PlILBs5BAH+X4QokPB0BBO490o0JlwzgdeT6+3eKKvUDYEs2ixYjFq0J +cfRK9ChQtP6IHG4/bC8vCVlbpVsLM5niwz2J+Wos77LTBumjQjBAMB0GA1UdDgQW +BBR1cacZSBm8nZ3qQUfflMRId5nTeTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/ +BAUwAwEB/zAKBggqhkjOPQQDAwNoADBlAjEA7wNbeqy3eApyt4jf/7VGFAkK+qDm +fQjGGoe9GKhzvSbKYAydzpmfz1wPMOG+FDHqAjAU9JM8SaczepBGR7NjfRObTrdv +GDeAU/7dIOA1mjbRxwG55tzd8/8dLDoWV9mSOdY= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIF2DCCA8CgAwIBAgIQTKr5yttjb+Af907YWwOGnTANBgkqhkiG9w0BAQwFADCB +hTELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4G +A1UEBxMHU2FsZm9yZDEaMBgGA1UEChMRQ09NT0RPIENBIExpbWl0ZWQxKzApBgNV +BAMTIkNPTU9ETyBSU0EgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMTAwMTE5 +MDAwMDAwWhcNMzgwMTE4MjM1OTU5WjCBhTELMAkGA1UEBhMCR0IxGzAZBgNVBAgT +EkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UEBxMHU2FsZm9yZDEaMBgGA1UEChMR +Q09NT0RPIENBIExpbWl0ZWQxKzApBgNVBAMTIkNPTU9ETyBSU0EgQ2VydGlmaWNh +dGlvbiBBdXRob3JpdHkwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCR +6FSS0gpWsawNJN3Fz0RndJkrN6N9I3AAcbxT38T6KhKPS38QVr2fcHK3YX/JSw8X +pz3jsARh7v8Rl8f0hj4K+j5c+ZPmNHrZFGvnnLOFoIJ6dq9xkNfs/Q36nGz637CC +9BR++b7Epi9Pf5l/tfxnQ3K9DADWietrLNPtj5gcFKt+5eNu/Nio5JIk2kNrYrhV +/erBvGy2i/MOjZrkm2xpmfh4SDBF1a3hDTxFYPwyllEnvGfDyi62a+pGx8cgoLEf +Zd5ICLqkTqnyg0Y3hOvozIFIQ2dOciqbXL1MGyiKXCJ7tKuY2e7gUYPDCUZObT6Z ++pUX2nwzV0E8jVHtC7ZcryxjGt9XyD+86V3Em69FmeKjWiS0uqlWPc9vqv9JWL7w +qP/0uK3pN/u6uPQLOvnoQ0IeidiEyxPx2bvhiWC4jChWrBQdnArncevPDt09qZah +SL0896+1DSJMwBGB7FY79tOi4lu3sgQiUpWAk2nojkxl8ZEDLXB0AuqLZxUpaVIC +u9ffUGpVRr+goyhhf3DQw6KqLCGqR84onAZFdr+CGCe01a60y1Dma/RMhnEw6abf +Fobg2P9A3fvQQoh/ozM6LlweQRGBY84YcWsr7KaKtzFcOmpH4MN5WdYgGq/yapiq +crxXStJLnbsQ/LBMQeXtHT1eKJ2czL+zUdqnR+WEUwIDAQABo0IwQDAdBgNVHQ4E +FgQUu69+Aj36pvE8hI6t7jiY7NkyMtQwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB +/wQFMAMBAf8wDQYJKoZIhvcNAQEMBQADggIBAArx1UaEt65Ru2yyTUEUAJNMnMvl +wFTPoCWOAvn9sKIN9SCYPBMtrFaisNZ+EZLpLrqeLppysb0ZRGxhNaKatBYSaVqM +4dc+pBroLwP0rmEdEBsqpIt6xf4FpuHA1sj+nq6PK7o9mfjYcwlYRm6mnPTXJ9OV +2jeDchzTc+CiR5kDOF3VSXkAKRzH7JsgHAckaVd4sjn8OoSgtZx8jb8uk2Intzna +FxiuvTwJaP+EmzzV1gsD41eeFPfR60/IvYcjt7ZJQ3mFXLrrkguhxuhoqEwWsRqZ +CuhTLJK7oQkYdQxlqHvLI7cawiiFwxv/0Cti76R7CZGYZ4wUAc1oBmpjIXUDgIiK +boHGhfKppC3n9KUkEEeDys30jXlYsQab5xoq2Z0B15R97QNKyvDb6KkBPvVWmcke +jkk9u+UJueBPSZI9FoJAzMxZxuY67RIuaTxslbH9qh17f4a+Hg4yRvv7E491f0yL +S0Zj/gA0QHDBw7mh3aZw4gSzQbzpgJHqZJx64SIDqZxubw5lT2yHh17zbqD5daWb +QOhTsiedSrnAdyGN/4fy3ryM7xfft0kL0fJuMAsaDk527RH89elWsn2/x20Kk4yl +0MC2Hb46TpSi125sC8KKfPog88Tk5c0NqMuRkrF8hey1FGlmDoLnzc7ILaZRfyHB +NVOFBkpdn627G190 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEvTCCA6WgAwIBAgIBADANBgkqhkiG9w0BAQUFADB/MQswCQYDVQQGEwJFVTEn +MCUGA1UEChMeQUMgQ2FtZXJmaXJtYSBTQSBDSUYgQTgyNzQzMjg3MSMwIQYDVQQL +ExpodHRwOi8vd3d3LmNoYW1iZXJzaWduLm9yZzEiMCAGA1UEAxMZQ2hhbWJlcnMg +b2YgQ29tbWVyY2UgUm9vdDAeFw0wMzA5MzAxNjEzNDNaFw0zNzA5MzAxNjEzNDRa +MH8xCzAJBgNVBAYTAkVVMScwJQYDVQQKEx5BQyBDYW1lcmZpcm1hIFNBIENJRiBB +ODI3NDMyODcxIzAhBgNVBAsTGmh0dHA6Ly93d3cuY2hhbWJlcnNpZ24ub3JnMSIw +IAYDVQQDExlDaGFtYmVycyBvZiBDb21tZXJjZSBSb290MIIBIDANBgkqhkiG9w0B +AQEFAAOCAQ0AMIIBCAKCAQEAtzZV5aVdGDDg2olUkfzIx1L4L1DZ77F1c2VHfRtb +unXF/KGIJPov7coISjlUxFF6tdpg6jg8gbLL8bvZkSM/SAFwdakFKq0fcfPJVD0d +BmpAPrMMhe5cG3nCYsS4No41XQEMIwRHNaqbYE6gZj3LJgqcQKH0XZi/caulAGgq +7YN6D6IUtdQis4CwPAxaUWktWBiP7Zme8a7ileb2R6jWDA+wWFjbw2Y3npuRVDM3 +0pQcakjJyfKl2qUMI/cjDpwyVV5xnIQFUZot/eZOKjRa3spAN2cMVCFVd9oKDMyX +roDclDZK9D7ONhMeU+SsTjoF7Nuucpw4i9A5O4kKPnf+dQIBA6OCAUQwggFAMBIG +A1UdEwEB/wQIMAYBAf8CAQwwPAYDVR0fBDUwMzAxoC+gLYYraHR0cDovL2NybC5j +aGFtYmVyc2lnbi5vcmcvY2hhbWJlcnNyb290LmNybDAdBgNVHQ4EFgQU45T1sU3p +26EpW1eLTXYGduHRooowDgYDVR0PAQH/BAQDAgEGMBEGCWCGSAGG+EIBAQQEAwIA +BzAnBgNVHREEIDAegRxjaGFtYmVyc3Jvb3RAY2hhbWJlcnNpZ24ub3JnMCcGA1Ud +EgQgMB6BHGNoYW1iZXJzcm9vdEBjaGFtYmVyc2lnbi5vcmcwWAYDVR0gBFEwTzBN +BgsrBgEEAYGHLgoDATA+MDwGCCsGAQUFBwIBFjBodHRwOi8vY3BzLmNoYW1iZXJz +aWduLm9yZy9jcHMvY2hhbWJlcnNyb290Lmh0bWwwDQYJKoZIhvcNAQEFBQADggEB +AAxBl8IahsAifJ/7kPMa0QOx7xP5IV8EnNrJpY0nbJaHkb5BkAFyk+cefV/2icZd +p0AJPaxJRUXcLo0waLIJuvvDL8y6C98/d3tGfToSJI6WjzwFCm/SlCgdbQzALogi +1djPHRPH8EjX1wWnz8dHnjs8NMiAT9QUu/wNUPf6s+xCX6ndbcj0dc97wXImsQEc +XCz9ek60AcUFV7nnPKoF2YjpB0ZBzu9Bga5Y34OirsrXdx/nADydb47kMgkdTXg0 +eDQ8lJsm7U9xxhl6vSAiSFr+S30Dt+dYvsYyTnQeaN2oaFuzPu5ifdmA6Ap1erfu +tGWaIZDgqtCYvDi1czyL+Nw= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIExTCCA62gAwIBAgIBADANBgkqhkiG9w0BAQUFADB9MQswCQYDVQQGEwJFVTEn +MCUGA1UEChMeQUMgQ2FtZXJmaXJtYSBTQSBDSUYgQTgyNzQzMjg3MSMwIQYDVQQL +ExpodHRwOi8vd3d3LmNoYW1iZXJzaWduLm9yZzEgMB4GA1UEAxMXR2xvYmFsIENo +YW1iZXJzaWduIFJvb3QwHhcNMDMwOTMwMTYxNDE4WhcNMzcwOTMwMTYxNDE4WjB9 +MQswCQYDVQQGEwJFVTEnMCUGA1UEChMeQUMgQ2FtZXJmaXJtYSBTQSBDSUYgQTgy +NzQzMjg3MSMwIQYDVQQLExpodHRwOi8vd3d3LmNoYW1iZXJzaWduLm9yZzEgMB4G +A1UEAxMXR2xvYmFsIENoYW1iZXJzaWduIFJvb3QwggEgMA0GCSqGSIb3DQEBAQUA +A4IBDQAwggEIAoIBAQCicKLQn0KuWxfH2H3PFIP8T8mhtxOviteePgQKkotgVvq0 +Mi+ITaFgCPS3CU6gSS9J1tPfnZdan5QEcOw/Wdm3zGaLmFIoCQLfxS+EjXqXd7/s +QJ0lcqu1PzKY+7e3/HKE5TWH+VX6ox8Oby4o3Wmg2UIQxvi1RMLQQ3/bvOSiPGpV +eAp3qdjqGTK3L/5cPxvusZjsyq16aUXjlg9V9ubtdepl6DJWk0aJqCWKZQbua795 +B9Dxt6/tLE2Su8CoX6dnfQTyFQhwrJLWfQTSM/tMtgsL+xrJxI0DqX5c8lCrEqWh +z0hQpe/SyBoT+rB/sYIcd2oPX9wLlY/vQ37mRQklAgEDo4IBUDCCAUwwEgYDVR0T +AQH/BAgwBgEB/wIBDDA/BgNVHR8EODA2MDSgMqAwhi5odHRwOi8vY3JsLmNoYW1i +ZXJzaWduLm9yZy9jaGFtYmVyc2lnbnJvb3QuY3JsMB0GA1UdDgQWBBRDnDafsJ4w +TcbOX60Qq+UDpfqpFDAOBgNVHQ8BAf8EBAMCAQYwEQYJYIZIAYb4QgEBBAQDAgAH +MCoGA1UdEQQjMCGBH2NoYW1iZXJzaWducm9vdEBjaGFtYmVyc2lnbi5vcmcwKgYD +VR0SBCMwIYEfY2hhbWJlcnNpZ25yb290QGNoYW1iZXJzaWduLm9yZzBbBgNVHSAE +VDBSMFAGCysGAQQBgYcuCgEBMEEwPwYIKwYBBQUHAgEWM2h0dHA6Ly9jcHMuY2hh +bWJlcnNpZ24ub3JnL2Nwcy9jaGFtYmVyc2lnbnJvb3QuaHRtbDANBgkqhkiG9w0B +AQUFAAOCAQEAPDtwkfkEVCeR4e3t/mh/YV3lQWVPMvEYBZRqHN4fcNs+ezICNLUM +bKGKfKX0j//U2K0X1S0E0T9YgOKBWYi+wONGkyT+kL0mojAt6JcmVzWJdJYY9hXi +ryQZVgICsroPFOrGimbBhkVVi76SvpykBMdJPJ7oKXqJ1/6v/2j1pReQvayZzKWG +VwlnRtvWFsJG8eSpUPWP0ZIV018+xgBJOm5YstHRJw0lyDL4IBHNfTIzSJRUTN3c +ecQwn+uOuFW114hcxWokPbLTBQNRxgfvzBRydD1ucs4YKIxKoHflCStFREest2d/ +AYoFWpO+ocH/+OcOZ6RHSXZddZAa9SaP8A== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDqDCCApCgAwIBAgIJAP7c4wEPyUj/MA0GCSqGSIb3DQEBBQUAMDQxCzAJBgNV +BAYTAkZSMRIwEAYDVQQKDAlEaGlteW90aXMxETAPBgNVBAMMCENlcnRpZ25hMB4X +DTA3MDYyOTE1MTMwNVoXDTI3MDYyOTE1MTMwNVowNDELMAkGA1UEBhMCRlIxEjAQ +BgNVBAoMCURoaW15b3RpczERMA8GA1UEAwwIQ2VydGlnbmEwggEiMA0GCSqGSIb3 +DQEBAQUAA4IBDwAwggEKAoIBAQDIaPHJ1tazNHUmgh7stL7qXOEm7RFHYeGifBZ4 +QCHkYJ5ayGPhxLGWkv8YbWkj4Sti993iNi+RB7lIzw7sebYs5zRLcAglozyHGxny +gQcPOJAZ0xH+hrTy0V4eHpbNgGzOOzGTtvKg0KmVEn2lmsxryIRWijOp5yIVUxbw +zBfsV1/pogqYCd7jX5xv3EjjhQsVWqa6n6xI4wmy9/Qy3l40vhx4XUJbzg4ij02Q +130yGLMLLGq/jj8UEYkgDncUtT2UCIf3JR7VsmAA7G8qKCVuKj4YYxclPz5EIBb2 +JsglrgVKtOdjLPOMFlN+XPsRGgjBRmKfIrjxwo1p3Po6WAbfAgMBAAGjgbwwgbkw +DwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGu3+QTmQtCRZvgHyUtVF9lo53BEw +ZAYDVR0jBF0wW4AUGu3+QTmQtCRZvgHyUtVF9lo53BGhOKQ2MDQxCzAJBgNVBAYT +AkZSMRIwEAYDVQQKDAlEaGlteW90aXMxETAPBgNVBAMMCENlcnRpZ25hggkA/tzj +AQ/JSP8wDgYDVR0PAQH/BAQDAgEGMBEGCWCGSAGG+EIBAQQEAwIABzANBgkqhkiG +9w0BAQUFAAOCAQEAhQMeknH2Qq/ho2Ge6/PAD/Kl1NqV5ta+aDY9fm4fTIrv0Q8h +bV6lUmPOEvjvKtpv6zf+EwLHyzs+ImvaYS5/1HI93TDhHkxAGYwP15zRgzB7mFnc +fca5DClMoTOi62c6ZYTTluLtdkVwj7Ur3vkj1kluPBS1xp81HlDQwY9qcEQCYsuu +HWhBp6pX6FOqB9IG9tUUBguRA3UsbHK1YZWaDYu5Def131TN3ubY1gkIl2PlwS6w +t0QmwCbAr1UwnjvVNioZBPRcHv/PLLf/0P2HQBHVESO7SMAhqaQoLf0V+LBOK/Qw +WyH8EZE0vkHve52Xdf+XlcCWWC/qu0bXu+TZLg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFnDCCA4SgAwIBAgIBATANBgkqhkiG9w0BAQUFADBjMQswCQYDVQQGEwJGUjET +MBEGA1UEChMKQ2VydGlub21pczEXMBUGA1UECxMOMDAwMiA0MzM5OTg5MDMxJjAk +BgNVBAMMHUNlcnRpbm9taXMgLSBBdXRvcml0w6kgUmFjaW5lMB4XDTA4MDkxNzA4 +Mjg1OVoXDTI4MDkxNzA4Mjg1OVowYzELMAkGA1UEBhMCRlIxEzARBgNVBAoTCkNl +cnRpbm9taXMxFzAVBgNVBAsTDjAwMDIgNDMzOTk4OTAzMSYwJAYDVQQDDB1DZXJ0 +aW5vbWlzIC0gQXV0b3JpdMOpIFJhY2luZTCCAiIwDQYJKoZIhvcNAQEBBQADggIP +ADCCAgoCggIBAJ2Fn4bT46/HsmtuM+Cet0I0VZ35gb5j2CN2DpdUzZlMGvE5x4jY +F1AMnmHawE5V3udauHpOd4cN5bjr+p5eex7Ezyh0x5P1FMYiKAT5kcOrJ3NqDi5N +8y4oH3DfVS9O7cdxbwlyLu3VMpfQ8Vh30WC8Tl7bmoT2R2FFK/ZQpn9qcSdIhDWe +rP5pqZ56XjUl+rSnSTV3lqc2W+HN3yNw2F1MpQiD8aYkOBOo7C+ooWfHpi2GR+6K +/OybDnT0K0kCe5B1jPyZOQE51kqJ5Z52qz6WKDgmi92NjMD2AR5vpTESOH2VwnHu +7XSu5DaiQ3XV8QCb4uTXzEIDS3h65X27uK4uIJPT5GHfceF2Z5c/tt9qc1pkIuVC +28+BA5PY9OMQ4HL2AHCs8MF6DwV/zzRpRbWT5BnbUhYjBYkOjUjkJW+zeL9i9Qf6 +lSTClrLooyPCXQP8w9PlfMl1I9f09bze5N/NgL+RiH2nE7Q5uiy6vdFrzPOlKO1E +nn1So2+WLhl+HPNbxxaOu2B9d2ZHVIIAEWBsMsGoOBvrbpgT1u449fCfDu/+MYHB +0iSVL1N6aaLwD4ZFjliCK0wi1F6g530mJ0jfJUaNSih8hp75mxpZuWW/Bd22Ql09 +5gBIgl4g9xGC3srYn+Y3RyYe63j3YcNBZFgCQfna4NH4+ej9Uji29YnfAgMBAAGj +WzBZMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBQN +jLZh2kS40RR9w759XkjwzspqsDAXBgNVHSAEEDAOMAwGCiqBegFWAgIAAQEwDQYJ +KoZIhvcNAQEFBQADggIBACQ+YAZ+He86PtvqrxyaLAEL9MW12Ukx9F1BjYkMTv9s +ov3/4gbIOZ/xWqndIlgVqIrTseYyCYIDbNc/CMf4uboAbbnW/FIyXaR/pDGUu7ZM +OH8oMDX/nyNTt7buFHAAQCvaR6s0fl6nVjBhK4tDrP22iCj1a7Y+YEq6QpA0Z43q +619FVDsXrIvkxmUP7tCMXWY5zjKn2BCXwH40nJ+U8/aGH88bc62UeYdocMMzpXDn +2NU4lG9jeeu/Cg4I58UvD0KgKxRA/yHgBcUn4YQRE7rWhh1BCxMjidPJC+iKunqj +o3M3NYB9Ergzd0A4wPpeMNLytqOx1qKVl4GbUu1pTP+A5FPbVFsDbVRfsbjvJL1v +nxHDx2TCDyhihWZeGnuyt++uNckZM6i4J9szVb9o4XVIRFb7zdNIu0eJOqxp9YDG +5ERQL1TEqkPFMTFYvZbF6nVsmnWxTfj3l/+WFvKXTej28xH5On2KOG4Ey+HTRRWq +pdEdnV1j6CTmNhTih60bWfVEm/vXd3wfAXBioSAaosUaKPQhA+4u2cGA6rnZgtZb +dsLLO7XSAPCjDuGtbkD326C00EauFddEwk01+dIL8hf2rGbVJLJP0RyZwG71fet0 +BLj5TXcJ17TPBzAJ8bgAVtkXFhYKK4bfjwEZGuW7gmP/vgt2Fl43N+bYdJeimUV5 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDkjCCAnqgAwIBAgIRAIW9S/PY2uNp9pTXX8OlRCMwDQYJKoZIhvcNAQEFBQAw +PTELMAkGA1UEBhMCRlIxETAPBgNVBAoTCENlcnRwbHVzMRswGQYDVQQDExJDbGFz +cyAyIFByaW1hcnkgQ0EwHhcNOTkwNzA3MTcwNTAwWhcNMTkwNzA2MjM1OTU5WjA9 +MQswCQYDVQQGEwJGUjERMA8GA1UEChMIQ2VydHBsdXMxGzAZBgNVBAMTEkNsYXNz +IDIgUHJpbWFyeSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANxQ +ltAS+DXSCHh6tlJw/W/uz7kRy1134ezpfgSN1sxvc0NXYKwzCkTsA18cgCSR5aiR +VhKC9+Ar9NuuYS6JEI1rbLqzAr3VNsVINyPi8Fo3UjMXEuLRYE2+L0ER4/YXJQyL +kcAbmXuZVg2v7tK8R1fjeUl7NIknJITesezpWE7+Tt9avkGtrAjFGA7v0lPubNCd +EgETjdyAYveVqUSISnFOYFWe2yMZeVYHDD9jC1yw4r5+FfyUM1hBOHTE4Y+L3yas +H7WLO7dDWWuwJKZtkIvEcupdM5i3y95ee++U8Rs+yskhwcWYAqqi9lt3m/V+llU0 +HGdpwPFC40es/CgcZlUCAwEAAaOBjDCBiTAPBgNVHRMECDAGAQH/AgEKMAsGA1Ud +DwQEAwIBBjAdBgNVHQ4EFgQU43Mt38sOKAze3bOkynm4jrvoMIkwEQYJYIZIAYb4 +QgEBBAQDAgEGMDcGA1UdHwQwMC4wLKAqoCiGJmh0dHA6Ly93d3cuY2VydHBsdXMu +Y29tL0NSTC9jbGFzczIuY3JsMA0GCSqGSIb3DQEBBQUAA4IBAQCnVM+IRBnL39R/ +AN9WM2K191EBkOvDP9GIROkkXe/nFL0gt5o8AP5tn9uQ3Nf0YtaLcF3n5QRIqWh8 +yfFC82x/xXp8HVGIutIKPidd3i1RTtMTZGnkLuPT55sJmabglZvOGtd/vjzOUrMR +FcEPF80Du5wlFbqidon8BvEY0JNLDnyCt6X09l/+7UCmnYR0ObncHoUW2ikbhiMA +ybuJfm6AiB4vFLQDJKgybwOaRywwvlbGp0ICcBvqQNi6BQNwB6SW//1IMwrh3KWB +kJtN3X3n57LNXMhqlfil9o3EXXgIvnsG1knPGTZQIy4I5p4FTUcY1Rbpsda2ENW7 +l7+ijrRU +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDDDCCAfSgAwIBAgIDAQAgMA0GCSqGSIb3DQEBBQUAMD4xCzAJBgNVBAYTAlBM +MRswGQYDVQQKExJVbml6ZXRvIFNwLiB6IG8uby4xEjAQBgNVBAMTCUNlcnR1bSBD +QTAeFw0wMjA2MTExMDQ2MzlaFw0yNzA2MTExMDQ2MzlaMD4xCzAJBgNVBAYTAlBM +MRswGQYDVQQKExJVbml6ZXRvIFNwLiB6IG8uby4xEjAQBgNVBAMTCUNlcnR1bSBD +QTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAM6xwS7TT3zNJc4YPk/E +jG+AanPIW1H4m9LcuwBcsaD8dQPugfCI7iNS6eYVM42sLQnFdvkrOYCJ5JdLkKWo +ePhzQ3ukYbDYWMzhbGZ+nPMJXlVjhNWo7/OxLjBos8Q82KxujZlakE403Daaj4GI +ULdtlkIJ89eVgw1BS7Bqa/j8D35in2fE7SZfECYPCE/wpFcozo+47UX2bu4lXapu +Ob7kky/ZR6By6/qmW6/KUz/iDsaWVhFu9+lmqSbYf5VT7QqFiLpPKaVCjF62/IUg +AKpoC6EahQGcxEZjgoi2IrHu/qpGWX7PNSzVttpd90gzFFS269lvzs2I1qsb2pY7 +HVkCAwEAAaMTMBEwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG9w0BAQUFAAOCAQEA +uI3O7+cUus/usESSbLQ5PqKEbq24IXfS1HeCh+YgQYHu4vgRt2PRFze+GXYkHAQa +TOs9qmdvLdTN/mUxcMUbpgIKumB7bVjCmkn+YzILa+M6wKyrO7Do0wlRjBCDxjTg +xSvgGrZgFCdsMneMvLJymM/NzD+5yCRCFNZX/OYmQ6kd5YCQzgNUKD73P9P4Te1q +CjqTE5s7FCMTY5w/0YcneeVMUeMBrYVdGjux1XMQpNPyvG5k9VpWkKjHDkx0Dy5x +O/fIR/RpbxXyEV6DHpx8Uq79AtoSqFlnGNu8cN2bsWntgM6JQEhqDjXKKWYVIZQs +6GAqm4VKQPNriiTsBhYscw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDuzCCAqOgAwIBAgIDBETAMA0GCSqGSIb3DQEBBQUAMH4xCzAJBgNVBAYTAlBM +MSIwIAYDVQQKExlVbml6ZXRvIFRlY2hub2xvZ2llcyBTLkEuMScwJQYDVQQLEx5D +ZXJ0dW0gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkxIjAgBgNVBAMTGUNlcnR1bSBU +cnVzdGVkIE5ldHdvcmsgQ0EwHhcNMDgxMDIyMTIwNzM3WhcNMjkxMjMxMTIwNzM3 +WjB+MQswCQYDVQQGEwJQTDEiMCAGA1UEChMZVW5pemV0byBUZWNobm9sb2dpZXMg +Uy5BLjEnMCUGA1UECxMeQ2VydHVtIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MSIw +IAYDVQQDExlDZXJ0dW0gVHJ1c3RlZCBOZXR3b3JrIENBMIIBIjANBgkqhkiG9w0B +AQEFAAOCAQ8AMIIBCgKCAQEA4/t9o3K6wvDJFIf1awFO4W5AB7ptJ11/91sts1rH +UV+rpDKmYYe2bg+G0jACl/jXaVehGDldamR5xgFZrDwxSjh80gTSSyjoIF87B6LM +TXPb865Px1bVWqeWifrzq2jUI4ZZJ88JJ7ysbnKDHDBy3+Ci6dLhdHUZvSqeexVU +BBvXQzmtVSjF4hq79MDkrjhJM8x2hZ85RdKknvISjFH4fOQtf/WsX+sWn7Et0brM +kUJ3TCXJkDhv2/DM+44el1k+1WBO5gUo7Ul5E0u6SNsv+XLTOcr+H9g0cvW0QM8x +AcPs3hEtF10fuFDRXhmnad4HMyjKUJX5p1TLVIZQRan5SQIDAQABo0IwQDAPBgNV +HRMBAf8EBTADAQH/MB0GA1UdDgQWBBQIds3LB/8k9sXN7buQvOKEN0Z19zAOBgNV +HQ8BAf8EBAMCAQYwDQYJKoZIhvcNAQEFBQADggEBAKaorSLOAT2mo/9i0Eidi15y +sHhE49wcrwn9I0j6vSrEuVUEtRCjjSfeC4Jj0O7eDDd5QVsisrCaQVymcODU0HfL +I9MA4GxWL+FpDQ3Zqr8hgVDZBqWo/5U30Kr+4rP1mS1FhIrlQgnXdAIv94nYmem8 +J9RHjboNRhx3zxSkHLmkMcScKHQDNP8zGSal6Q10tz6XxnboJ5ajZt3hrvJBW8qY +VoNzcOSGGtIxQbovvi0TWnZvTuhOgQ4/WwMioBK+ZlgRSssDxLQqKi2WF+A5VLxI +03YnnZotBqbJ7DnSq9ufmgsnAjUpsUCV5/nonFWIGUbWtzT1fs45mtk48VH3Tyw= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIHTzCCBTegAwIBAgIJAKPaQn6ksa7aMA0GCSqGSIb3DQEBBQUAMIGuMQswCQYD +VQQGEwJFVTFDMEEGA1UEBxM6TWFkcmlkIChzZWUgY3VycmVudCBhZGRyZXNzIGF0 +IHd3dy5jYW1lcmZpcm1hLmNvbS9hZGRyZXNzKTESMBAGA1UEBRMJQTgyNzQzMjg3 +MRswGQYDVQQKExJBQyBDYW1lcmZpcm1hIFMuQS4xKTAnBgNVBAMTIENoYW1iZXJz +IG9mIENvbW1lcmNlIFJvb3QgLSAyMDA4MB4XDTA4MDgwMTEyMjk1MFoXDTM4MDcz +MTEyMjk1MFowga4xCzAJBgNVBAYTAkVVMUMwQQYDVQQHEzpNYWRyaWQgKHNlZSBj +dXJyZW50IGFkZHJlc3MgYXQgd3d3LmNhbWVyZmlybWEuY29tL2FkZHJlc3MpMRIw +EAYDVQQFEwlBODI3NDMyODcxGzAZBgNVBAoTEkFDIENhbWVyZmlybWEgUy5BLjEp +MCcGA1UEAxMgQ2hhbWJlcnMgb2YgQ29tbWVyY2UgUm9vdCAtIDIwMDgwggIiMA0G +CSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCvAMtwNyuAWko6bHiUfaN/Gh/2NdW9 +28sNRHI+JrKQUrpjOyhYb6WzbZSm891kDFX29ufyIiKAXuFixrYp4YFs8r/lfTJq +VKAyGVn+H4vXPWCGhSRv4xGzdz4gljUha7MI2XAuZPeEklPWDrCQiorjh40G072Q +DuKZoRuGDtqaCrsLYVAGUvGef3bsyw/QHg3PmTA9HMRFEFis1tPo1+XqxQEHd9ZR +5gN/ikilTWh1uem8nk4ZcfUyS5xtYBkL+8ydddy/Js2Pk3g5eXNeJQ7KXOt3EgfL +ZEFHcpOrUMPrCXZkNNI5t3YRCQ12RcSprj1qr7V9ZS+UWBDsXHyvfuK2GNnQm05a +Sd+pZgvMPMZ4fKecHePOjlO+Bd5gD2vlGts/4+EhySnB8esHnFIbAURRPHsl18Tl +UlRdJQfKFiC4reRB7noI/plvg6aRArBsNlVq5331lubKgdaX8ZSD6e2wsWsSaR6s ++12pxZjptFtYer49okQ6Y1nUCyXeG0+95QGezdIp1Z8XGQpvvwyQ0wlf2eOKNcx5 +Wk0ZN5K3xMGtr/R5JJqyAQuxr1yW84Ay+1w9mPGgP0revq+ULtlVmhduYJ1jbLhj +ya6BXBg14JC7vjxPNyK5fuvPnnchpj04gftI2jE9K+OJ9dC1vX7gUMQSibMjmhAx +hduub+84Mxh2EQIDAQABo4IBbDCCAWgwEgYDVR0TAQH/BAgwBgEB/wIBDDAdBgNV +HQ4EFgQU+SSsD7K1+HnA+mCIG8TZTQKeFxkwgeMGA1UdIwSB2zCB2IAU+SSsD7K1 ++HnA+mCIG8TZTQKeFxmhgbSkgbEwga4xCzAJBgNVBAYTAkVVMUMwQQYDVQQHEzpN +YWRyaWQgKHNlZSBjdXJyZW50IGFkZHJlc3MgYXQgd3d3LmNhbWVyZmlybWEuY29t +L2FkZHJlc3MpMRIwEAYDVQQFEwlBODI3NDMyODcxGzAZBgNVBAoTEkFDIENhbWVy +ZmlybWEgUy5BLjEpMCcGA1UEAxMgQ2hhbWJlcnMgb2YgQ29tbWVyY2UgUm9vdCAt +IDIwMDiCCQCj2kJ+pLGu2jAOBgNVHQ8BAf8EBAMCAQYwPQYDVR0gBDYwNDAyBgRV +HSAAMCowKAYIKwYBBQUHAgEWHGh0dHA6Ly9wb2xpY3kuY2FtZXJmaXJtYS5jb20w +DQYJKoZIhvcNAQEFBQADggIBAJASryI1wqM58C7e6bXpeHxIvj99RZJe6dqxGfwW +PJ+0W2aeaufDuV2I6A+tzyMP3iU6XsxPpcG1Lawk0lgH3qLPaYRgM+gQDROpI9CF +5Y57pp49chNyM/WqfcZjHwj0/gF/JM8rLFQJ3uIrbZLGOU8W6jx+ekbURWpGqOt1 +glanq6B8aBMz9p0w8G8nOSQjKpD9kCk18pPfNKXG9/jvjA9iSnyu0/VU+I22mlaH +FoI6M6taIgj3grrqLuBHmrS1RaMFO9ncLkVAO+rcf+g769HsJtg1pDDFOqxXnrN2 +pSB7+R5KBWIBpih1YJeSDW4+TTdDDZIVnBgizVGZoCkaPF+KMjNbMMeJL0eYD6MD +xvbxrN8y8NmBGuScvfaAFPDRLLmF9dijscilIeUcE5fuDr3fKanvNFNb0+RqE4QG +tjICxFKuItLcsiFCGtpA8CnJ7AoMXOLQusxI0zcKzBIKinmwPQN/aUv0NCB9szTq +jktk9T79syNnFQ0EuPAtwQlRPLJsFfClI9eDdOTlLsn+mCdCxqvGnrDQWzilm1De +fhiYtUU79nm06PcaewaD+9CL2rvHvRirCG88gGtAPxkZumWK5r7VXNM21+9AUiRg +OGcEMeyP84LG3rlV8zsxkVrctQgVrXYlCg17LofiDKYGvCYQbTed7N14jHyAxfDZ +d0jQ +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIID9zCCAt+gAwIBAgIESJ8AATANBgkqhkiG9w0BAQUFADCBijELMAkGA1UEBhMC +Q04xMjAwBgNVBAoMKUNoaW5hIEludGVybmV0IE5ldHdvcmsgSW5mb3JtYXRpb24g +Q2VudGVyMUcwRQYDVQQDDD5DaGluYSBJbnRlcm5ldCBOZXR3b3JrIEluZm9ybWF0 +aW9uIENlbnRlciBFViBDZXJ0aWZpY2F0ZXMgUm9vdDAeFw0xMDA4MzEwNzExMjVa +Fw0zMDA4MzEwNzExMjVaMIGKMQswCQYDVQQGEwJDTjEyMDAGA1UECgwpQ2hpbmEg +SW50ZXJuZXQgTmV0d29yayBJbmZvcm1hdGlvbiBDZW50ZXIxRzBFBgNVBAMMPkNo +aW5hIEludGVybmV0IE5ldHdvcmsgSW5mb3JtYXRpb24gQ2VudGVyIEVWIENlcnRp +ZmljYXRlcyBSb290MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAm35z +7r07eKpkQ0H1UN+U8i6yjUqORlTSIRLIOTJCBumD1Z9S7eVnAztUwYyZmczpwA// +DdmEEbK40ctb3B75aDFk4Zv6dOtouSCV98YPjUesWgbdYavi7NifFy2cyjw1l1Vx +zUOFsUcW9SxTgHbP0wBkvUCZ3czY28Sf1hNfQYOL+Q2HklY0bBoQCxfVWhyXWIQ8 +hBouXJE0bhlffxdpxWXvayHG1VA6v2G5BY3vbzQ6sm8UY78WO5upKv23KzhmBsUs +4qpnHkWnjQRmQvaPK++IIGmPMowUc9orhpFjIpryp9vOiYurXccUwVswah+xt54u +gQEC7c+WXmPbqOY4twIDAQABo2MwYTAfBgNVHSMEGDAWgBR8cks5x8DbYqVPm6oY +NJKiyoOCWTAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4E +FgQUfHJLOcfA22KlT5uqGDSSosqDglkwDQYJKoZIhvcNAQEFBQADggEBACrDx0M3 +j92tpLIM7twUbY8opJhJywyA6vPtI2Z1fcXTIWd50XPFtQO3WKwMVC/GVhMPMdoG +52U7HW8228gd+f2ABsqjPWYWqJ1MFn3AlUa1UeTiH9fqBk1jjZaM7+czV0I664zB +echNdn3e9rG3geCg+aF4RhcaVpjwTj2rHO3sOdwHSPdj/gauwqRcalsyiMXHM4Ws +ZkJHwlgkmeHlPuV1LI5D1l08eB6olYIpUNHRFrrvwb562bTYzB5MRuF3sTGrvSrI +zo9uoV1/A3U05K2JRVRevq4opbs/eHnrc7MKDf2+yfdWrPa37S+bISnHOLaVxATy +wy39FCqQmbkHzJ8= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDqzCCApOgAwIBAgIRAMcoRwmzuGxFjB36JPU2TukwDQYJKoZIhvcNAQEFBQAw +PDEbMBkGA1UEAxMSQ29tU2lnbiBTZWN1cmVkIENBMRAwDgYDVQQKEwdDb21TaWdu +MQswCQYDVQQGEwJJTDAeFw0wNDAzMjQxMTM3MjBaFw0yOTAzMTYxNTA0NTZaMDwx +GzAZBgNVBAMTEkNvbVNpZ24gU2VjdXJlZCBDQTEQMA4GA1UEChMHQ29tU2lnbjEL +MAkGA1UEBhMCSUwwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDGtWhf +HZQVw6QIVS3joFd67+l0Kru5fFdJGhFeTymHDEjWaueP1H5XJLkGieQcPOqs49oh +gHMhCu95mGwfCP+hUH3ymBvJVG8+pSjsIQQPRbsHPaHA+iqYHU4Gk/v1iDurX8sW +v+bznkqH7Rnqwp9D5PGBpX8QTz7RSmKtUxvLg/8HZaWSLWapW7ha9B20IZFKF3ue +Mv5WJDmyVIRD9YTC2LxBkMyd1mja6YJQqTtoz7VdApRgFrFD2UNd3V2Hbuq7s8lr +9gOUCXDeFhF6K+h2j0kQmHe5Y1yLM5d19guMsqtb3nQgJT/j8xH5h2iGNXHDHYwt +6+UarA9z1YJZQIDTAgMBAAGjgacwgaQwDAYDVR0TBAUwAwEB/zBEBgNVHR8EPTA7 +MDmgN6A1hjNodHRwOi8vZmVkaXIuY29tc2lnbi5jby5pbC9jcmwvQ29tU2lnblNl +Y3VyZWRDQS5jcmwwDgYDVR0PAQH/BAQDAgGGMB8GA1UdIwQYMBaAFMFL7XC29z58 +ADsAj8c+DkWfHl3sMB0GA1UdDgQWBBTBS+1wtvc+fAA7AI/HPg5Fnx5d7DANBgkq +hkiG9w0BAQUFAAOCAQEAFs/ukhNQq3sUnjO2QiBq1BW9Cav8cujvR3qQrFHBZE7p +iL1DRYHjZiM/EoZNGeQFsOY3wo3aBijJD4mkU6l1P7CW+6tMM1X5eCZGbxs2mPtC +dsGCuY7e+0X5YxtiOzkGynd6qDwJz2w2PQ8KRUtpFhpFfTMDZflScZAmlaxMDPWL +kz/MdXSFmLr/YnpNH4n+rr2UAJm/EaXc4HnFFgt9AmEd6oX5AhVP51qJThRv4zdL +hfXBPGHg/QVBspJ/wx2g0K5SZGBrGMYmnNj1ZOQ2GmKfig8+/21OGVZOIJFsnzQz +OjRXUDpvgV4GxvU+fE6OK85lBi5d0ipTdF7Tbieejw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEMjCCAxqgAwIBAgIBATANBgkqhkiG9w0BAQUFADB7MQswCQYDVQQGEwJHQjEb +MBkGA1UECAwSR3JlYXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHDAdTYWxmb3JkMRow +GAYDVQQKDBFDb21vZG8gQ0EgTGltaXRlZDEhMB8GA1UEAwwYQUFBIENlcnRpZmlj +YXRlIFNlcnZpY2VzMB4XDTA0MDEwMTAwMDAwMFoXDTI4MTIzMTIzNTk1OVowezEL +MAkGA1UEBhMCR0IxGzAZBgNVBAgMEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UE +BwwHU2FsZm9yZDEaMBgGA1UECgwRQ29tb2RvIENBIExpbWl0ZWQxITAfBgNVBAMM +GEFBQSBDZXJ0aWZpY2F0ZSBTZXJ2aWNlczCCASIwDQYJKoZIhvcNAQEBBQADggEP +ADCCAQoCggEBAL5AnfRu4ep2hxxNRUSOvkbIgwadwSr+GB+O5AL686tdUIoWMQua +BtDFcCLNSS1UY8y2bmhGC1Pqy0wkwLxyTurxFa70VJoSCsN6sjNg4tqJVfMiWPPe +3M/vg4aijJRPn2jymJBGhCfHdr/jzDUsi14HZGWCwEiwqJH5YZ92IFCokcdmtet4 +YgNW8IoaE+oxox6gmf049vYnMlhvB/VruPsUK6+3qszWY19zjNoFmag4qMsXeDZR +rOme9Hg6jc8P2ULimAyrL58OAd7vn5lJ8S3frHRNG5i1R8XlKdH5kBjHYpy+g8cm +ez6KJcfA3Z3mNWgQIJ2P2N7Sw4ScDV7oL8kCAwEAAaOBwDCBvTAdBgNVHQ4EFgQU +oBEKIz6W8Qfs4q8p74Klf9AwpLQwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQF +MAMBAf8wewYDVR0fBHQwcjA4oDagNIYyaHR0cDovL2NybC5jb21vZG9jYS5jb20v +QUFBQ2VydGlmaWNhdGVTZXJ2aWNlcy5jcmwwNqA0oDKGMGh0dHA6Ly9jcmwuY29t +b2RvLm5ldC9BQUFDZXJ0aWZpY2F0ZVNlcnZpY2VzLmNybDANBgkqhkiG9w0BAQUF +AAOCAQEACFb8AvCb6P+k+tZ7xkSAzk/ExfYAWMymtrwUSWgEdujm7l3sAg9g1o1Q +GE8mTgHj5rCl7r+8dFRBv/38ErjHT1r0iWAFf2C3BUrz9vHCv8S5dIa2LX1rzNLz +Rt0vxuBqw8M0Ayx9lt1awg6nCpnBBYurDC/zXDrPbDdVCYfeU0BsWO/8tqtlbgT2 +G9w84FoVxp7Z8VlIMCFlA2zs6SFz7JsDoeA3raAVGI/6ugLOpyypEBMs1OUIJqsi +l2D4kF501KKaU73yqWjgom7C12yxow+ev+to51byrvLjKzg6CYG1a4XXvi3tPxq3 +smPi9WIsgtRqAEFQ8TmDn5XpNpaYbg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEPzCCAyegAwIBAgIBATANBgkqhkiG9w0BAQUFADB+MQswCQYDVQQGEwJHQjEb +MBkGA1UECAwSR3JlYXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHDAdTYWxmb3JkMRow +GAYDVQQKDBFDb21vZG8gQ0EgTGltaXRlZDEkMCIGA1UEAwwbU2VjdXJlIENlcnRp +ZmljYXRlIFNlcnZpY2VzMB4XDTA0MDEwMTAwMDAwMFoXDTI4MTIzMTIzNTk1OVow +fjELMAkGA1UEBhMCR0IxGzAZBgNVBAgMEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4G +A1UEBwwHU2FsZm9yZDEaMBgGA1UECgwRQ29tb2RvIENBIExpbWl0ZWQxJDAiBgNV +BAMMG1NlY3VyZSBDZXJ0aWZpY2F0ZSBTZXJ2aWNlczCCASIwDQYJKoZIhvcNAQEB +BQADggEPADCCAQoCggEBAMBxM4KK0HDrc4eCQNUd5MvJDkKQ+d40uaG6EfQlhfPM +cm3ye5drswfxdySRXyWP9nQ95IDC+DwN879A6vfIUtFyb+/Iq0G4bi4XKpVpDM3S +HpR7LZQdqnXXs5jLrLxkU0C8j6ysNstcrbvd4JQX7NFc0L/vpZXJkMWwrPsbQ996 +CF23uPJAGysnnlDOXmWCiIxe004MeuoIkbY2qitC++rCoznl2yY4rYsK7hljxxwk +3wN42ubqwUcaCwtGCd0C/N7Lh1/XMGNooa7cMqG6vv5Eq2i2pRcV/b3Vp6ea5EQz +6YiO/O1R65NxTq0B50SOqy3LqP4BSUjwwN3HaNiS/j0CAwEAAaOBxzCBxDAdBgNV +HQ4EFgQUPNiTiMLAggnMAZkGkyDpnnAJY08wDgYDVR0PAQH/BAQDAgEGMA8GA1Ud +EwEB/wQFMAMBAf8wgYEGA1UdHwR6MHgwO6A5oDeGNWh0dHA6Ly9jcmwuY29tb2Rv +Y2EuY29tL1NlY3VyZUNlcnRpZmljYXRlU2VydmljZXMuY3JsMDmgN6A1hjNodHRw +Oi8vY3JsLmNvbW9kby5uZXQvU2VjdXJlQ2VydGlmaWNhdGVTZXJ2aWNlcy5jcmww +DQYJKoZIhvcNAQEFBQADggEBAIcBbSMdflsXfcFhMs+P5/OKlFlm4J4oqF7Tt/Q0 +5qo5spcWxYJvMqTpjOev/e/C6LlLqqP05tqNZSH7uoDrJiiFGv45jN5bBAS0VPmj +Z55B+glSzAVIqMk/IQQezkhr/IXownuvf7fM+F86/TXGDe+X3EyrEeFryzHRbPtI +gKvcnDe4IRRLDXE97IMzbtFuMhbsmMcWi1mmNKsFVy2T96oTy9IT4rcuO81rUBcJ +aD61JlfutuC23bkpgHl9j6PwpCikFcSF9CfUa7/lXORlAnZUtOM3ZiTTGWHIUhDl +izeauan5Hb/qmZJhlv8BzaFfDbxxvA6sCx1HRR3B7Hzs/Sk= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEQzCCAyugAwIBAgIBATANBgkqhkiG9w0BAQUFADB/MQswCQYDVQQGEwJHQjEb +MBkGA1UECAwSR3JlYXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHDAdTYWxmb3JkMRow +GAYDVQQKDBFDb21vZG8gQ0EgTGltaXRlZDElMCMGA1UEAwwcVHJ1c3RlZCBDZXJ0 +aWZpY2F0ZSBTZXJ2aWNlczAeFw0wNDAxMDEwMDAwMDBaFw0yODEyMzEyMzU5NTla +MH8xCzAJBgNVBAYTAkdCMRswGQYDVQQIDBJHcmVhdGVyIE1hbmNoZXN0ZXIxEDAO +BgNVBAcMB1NhbGZvcmQxGjAYBgNVBAoMEUNvbW9kbyBDQSBMaW1pdGVkMSUwIwYD +VQQDDBxUcnVzdGVkIENlcnRpZmljYXRlIFNlcnZpY2VzMIIBIjANBgkqhkiG9w0B +AQEFAAOCAQ8AMIIBCgKCAQEA33FvNlhTWvI2VFeAxHQIIO0Yfyod5jWaHiWsnOWW +fnJSoBVC21ndZHoa0Lh73TkVvFVIxO06AOoxEbrycXQaZ7jPM8yoMa+j49d/vzMt +TGo87IvDktJTdyR0nAducPy9C1t2ul/y/9c3S0pgePfw+spwtOpZqqPOSC+pw7IL +fhdyFgymBwwbOM/JYrc/oJOlh0Hyt3BAd9i+FHzjqMB6juljatEPmsbS9Is6FARW +1O24zG71++IsWL1/T2sr92AkWCTOJu80kTrV44HQsvAEAtdbtz6SrGsSivnkBbA7 +kUlcsutT6vifR4buv5XAwAaf0lteERv0xwQ1KdJVXOTt6wIDAQABo4HJMIHGMB0G +A1UdDgQWBBTFe1i97doladL3WRaoszLAeydb9DAOBgNVHQ8BAf8EBAMCAQYwDwYD +VR0TAQH/BAUwAwEB/zCBgwYDVR0fBHwwejA8oDqgOIY2aHR0cDovL2NybC5jb21v +ZG9jYS5jb20vVHJ1c3RlZENlcnRpZmljYXRlU2VydmljZXMuY3JsMDqgOKA2hjRo +dHRwOi8vY3JsLmNvbW9kby5uZXQvVHJ1c3RlZENlcnRpZmljYXRlU2VydmljZXMu +Y3JsMA0GCSqGSIb3DQEBBQUAA4IBAQDIk4E7ibSvuIQSTI3S8NtwuleGFTQQuS9/ +HrCoiWChisJ3DFBKmwCL2Iv0QeLQg4pKHBQGsKNoBXAxMKdTmw7pSqBYaWcOrp32 +pSxBvzwGa+RZzG0Q8ZZvH9/0BAKkn0U+yNj6NkZEUD+Cl5EfKNsYEYwq5GWDVxIS +jBc/lDb+XbDABHcTuPQV1T84zJQ6VdCsmPW6AF/ghhmBeC8owH7TzEIK9a5QoNE+ +xqFx7D+gIIxmOom0jtTYsU0lR+4viMi14QVFwL4Ucd56/Y57fU0IlqUSc/Atyjcn +dBInTMu2l+nZrghtWjlA3QVHdWpaIbOjGM9O9y5Xt5hwXsjEeLBi +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDoTCCAomgAwIBAgILBAAAAAABD4WqLUgwDQYJKoZIhvcNAQEFBQAwOzEYMBYG +A1UEChMPQ3liZXJ0cnVzdCwgSW5jMR8wHQYDVQQDExZDeWJlcnRydXN0IEdsb2Jh +bCBSb290MB4XDTA2MTIxNTA4MDAwMFoXDTIxMTIxNTA4MDAwMFowOzEYMBYGA1UE +ChMPQ3liZXJ0cnVzdCwgSW5jMR8wHQYDVQQDExZDeWJlcnRydXN0IEdsb2JhbCBS +b290MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA+Mi8vRRQZhP/8NN5 +7CPytxrHjoXxEnOmGaoQ25yiZXRadz5RfVb23CO21O1fWLE3TdVJDm71aofW0ozS +J8bi/zafmGWgE07GKmSb1ZASzxQG9Dvj1Ci+6A74q05IlG2OlTEQXO2iLb3VOm2y +HLtgwEZLAfVJrn5GitB0jaEMAs7u/OePuGtm839EAL9mJRQr3RAwHQeWP032a7iP +t3sMpTjr3kfb1V05/Iin89cqdPHoWqI7n1C6poxFNcJQZZXcY4Lv3b93TZxiyWNz +FtApD0mpSPCzqrdsxacwOUBdrsTiXSZT8M4cIwhhqJQZugRiQOwfOHB3EgZxpzAY +XSUnpQIDAQABo4GlMIGiMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/ +MB0GA1UdDgQWBBS2CHsNesysIEyGVjJez6tuhS1wVzA/BgNVHR8EODA2MDSgMqAw +hi5odHRwOi8vd3d3Mi5wdWJsaWMtdHJ1c3QuY29tL2NybC9jdC9jdHJvb3QuY3Js +MB8GA1UdIwQYMBaAFLYIew16zKwgTIZWMl7Pq26FLXBXMA0GCSqGSIb3DQEBBQUA +A4IBAQBW7wojoFROlZfJ+InaRcHUowAl9B8Tq7ejhVhpwjCt2BWKLePJzYFa+HMj +Wqd8BfP9IjsO0QbE2zZMcwSO5bAi5MXzLqXZI+O4Tkogp24CJJ8iYGd7ix1yCcUx +XOl5n4BHPa2hCwcUPUf/A2kaDAtE52Mlp3+yybh2hO0j9n0Hq0V+09+zv+mKts2o +omcrUtW3ZfA5TGOgkXmTUg9U3YO7n9GPp1Nzw8v/MOx8BLjYRB+TX3EJIrduPuoc +A06dGiBh+4E37F78CkWr1+cXVdCg6mCbpvbjjFspwgZgFJ0tl0ypkxWdYcQBX0jW +WL1WMRJOEcgh4LMRkWXbtKaIOM5V +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEMzCCAxugAwIBAgIDCYPzMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNVBAYTAkRF +MRUwEwYDVQQKDAxELVRydXN0IEdtYkgxJzAlBgNVBAMMHkQtVFJVU1QgUm9vdCBD +bGFzcyAzIENBIDIgMjAwOTAeFw0wOTExMDUwODM1NThaFw0yOTExMDUwODM1NTha +ME0xCzAJBgNVBAYTAkRFMRUwEwYDVQQKDAxELVRydXN0IEdtYkgxJzAlBgNVBAMM +HkQtVFJVU1QgUm9vdCBDbGFzcyAzIENBIDIgMjAwOTCCASIwDQYJKoZIhvcNAQEB +BQADggEPADCCAQoCggEBANOySs96R+91myP6Oi/WUEWJNTrGa9v+2wBoqOADER03 +UAifTUpolDWzU9GUY6cgVq/eUXjsKj3zSEhQPgrfRlWLJ23DEE0NkVJD2IfgXU42 +tSHKXzlABF9bfsyjxiupQB7ZNoTWSPOSHjRGICTBpFGOShrvUD9pXRl/RcPHAY9R +ySPocq60vFYJfxLLHLGvKZAKyVXMD9O0Gu1HNVpK7ZxzBCHQqr0ME7UAyiZsxGsM +lFqVlNpQmvH/pStmMaTJOKDfHR+4CS7zp+hnUquVH+BGPtikw8paxTGA6Eian5Rp +/hnd2HN8gcqW3o7tszIFZYQ05ub9VxC1X3a/L7AQDcUCAwEAAaOCARowggEWMA8G +A1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFP3aFMSfMN4hvR5COfyrYyNJ4PGEMA4G +A1UdDwEB/wQEAwIBBjCB0wYDVR0fBIHLMIHIMIGAoH6gfIZ6bGRhcDovL2RpcmVj +dG9yeS5kLXRydXN0Lm5ldC9DTj1ELVRSVVNUJTIwUm9vdCUyMENsYXNzJTIwMyUy +MENBJTIwMiUyMDIwMDksTz1ELVRydXN0JTIwR21iSCxDPURFP2NlcnRpZmljYXRl +cmV2b2NhdGlvbmxpc3QwQ6BBoD+GPWh0dHA6Ly93d3cuZC10cnVzdC5uZXQvY3Js +L2QtdHJ1c3Rfcm9vdF9jbGFzc18zX2NhXzJfMjAwOS5jcmwwDQYJKoZIhvcNAQEL +BQADggEBAH+X2zDI36ScfSF6gHDOFBJpiBSVYEQBrLLpME+bUMJm2H6NMLVwMeni +acfzcNsgFYbQDfC+rAF1hM5+n02/t2A7nPPKHeJeaNijnZflQGDSNiH+0LS4F9p0 +o3/U37CYAqxva2ssJSRyoWXuJVrl5jLn8t+rSfrzkGkj2wTZ51xY/GXUl77M/C4K +zCUqNQT4YJEVdT1B/yMfGchs64JTBKbkTCJNjYy6zltz7GRUUG3RnFX7acM2w4y8 +PIWmawomDeCTmGCufsYkl4phX5GOZpIJhzbNi5stPvZR1FDUWSi9g/LMKHtThm3Y +Johw1+qRzT65ysCQblrGXnRl11z+o+I= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEQzCCAyugAwIBAgIDCYP0MA0GCSqGSIb3DQEBCwUAMFAxCzAJBgNVBAYTAkRF +MRUwEwYDVQQKDAxELVRydXN0IEdtYkgxKjAoBgNVBAMMIUQtVFJVU1QgUm9vdCBD +bGFzcyAzIENBIDIgRVYgMjAwOTAeFw0wOTExMDUwODUwNDZaFw0yOTExMDUwODUw +NDZaMFAxCzAJBgNVBAYTAkRFMRUwEwYDVQQKDAxELVRydXN0IEdtYkgxKjAoBgNV +BAMMIUQtVFJVU1QgUm9vdCBDbGFzcyAzIENBIDIgRVYgMjAwOTCCASIwDQYJKoZI +hvcNAQEBBQADggEPADCCAQoCggEBAJnxhDRwui+3MKCOvXwEz75ivJn9gpfSegpn +ljgJ9hBOlSJzmY3aFS3nBfwZcyK3jpgAvDw9rKFs+9Z5JUut8Mxk2og+KbgPCdM0 +3TP1YtHhzRnp7hhPTFiu4h7WDFsVWtg6uMQYZB7jM7K1iXdODL/ZlGsTl28So/6Z +qQTMFexgaDbtCHu39b+T7WYxg4zGcTSHThfqr4uRjRxWQa4iN1438h3Z0S0NL2lR +p75mpoo6Kr3HGrHhFPC+Oh25z1uxav60sUYgovseO3Dvk5h9jHOW8sXvhXCtKSb8 +HgQ+HKDYD8tSg2J87otTlZCpV6LqYQXY+U3EJ/pure3511H3a6UCAwEAAaOCASQw +ggEgMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFNOUikxiEyoZLsyvcop9Ntea +HNxnMA4GA1UdDwEB/wQEAwIBBjCB3QYDVR0fBIHVMIHSMIGHoIGEoIGBhn9sZGFw +Oi8vZGlyZWN0b3J5LmQtdHJ1c3QubmV0L0NOPUQtVFJVU1QlMjBSb290JTIwQ2xh +c3MlMjAzJTIwQ0ElMjAyJTIwRVYlMjAyMDA5LE89RC1UcnVzdCUyMEdtYkgsQz1E +RT9jZXJ0aWZpY2F0ZXJldm9jYXRpb25saXN0MEagRKBChkBodHRwOi8vd3d3LmQt +dHJ1c3QubmV0L2NybC9kLXRydXN0X3Jvb3RfY2xhc3NfM19jYV8yX2V2XzIwMDku +Y3JsMA0GCSqGSIb3DQEBCwUAA4IBAQA07XtaPKSUiO8aEXUHL7P+PPoeUSbrh/Yp +3uDx1MYkCenBz1UbtDDZzhr+BlGmFaQt77JLvyAoJUnRpjZ3NOhk31KxEcdzes05 +nsKtjHEh8lprr988TlWvsoRlFIm5d8sqMb7Po23Pb0iUMkZv53GMoKaEGTcH8gNF +CSuGdXzfX2lXANtu2KZyIktQ1HWYVt+3GP9DQ1CuekR78HlR10M9p9OB0/DJT7na +xpeG0ILD5EJt/rDiZE4OJudANCa1CInXCGNjOCd1HjPqbqjdn5lPdE2BiYBL3ZqX +KVwvvoFBuYz/6n1gBp7N1z3TLqMVvKjmJuVvw9y4AyHqnxbxLFS1 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIECTCCAvGgAwIBAgIQDV6ZCtadt3js2AdWO4YV2TANBgkqhkiG9w0BAQUFADBb +MQswCQYDVQQGEwJVUzEgMB4GA1UEChMXRGlnaXRhbCBTaWduYXR1cmUgVHJ1c3Qx +ETAPBgNVBAsTCERTVCBBQ0VTMRcwFQYDVQQDEw5EU1QgQUNFUyBDQSBYNjAeFw0w +MzExMjAyMTE5NThaFw0xNzExMjAyMTE5NThaMFsxCzAJBgNVBAYTAlVTMSAwHgYD +VQQKExdEaWdpdGFsIFNpZ25hdHVyZSBUcnVzdDERMA8GA1UECxMIRFNUIEFDRVMx +FzAVBgNVBAMTDkRTVCBBQ0VTIENBIFg2MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A +MIIBCgKCAQEAuT31LMmU3HWKlV1j6IR3dma5WZFcRt2SPp/5DgO0PWGSvSMmtWPu +ktKe1jzIDZBfZIGxqAgNTNj50wUoUrQBJcWVHAx+PhCEdc/BGZFjz+iokYi5Q1K7 +gLFViYsx+tC3dr5BPTCapCIlF3PoHuLTrCq9Wzgh1SpL11V94zpVvddtawJXa+ZH +fAjIgrrep4c9oW24MFbCswKBXy314powGCi4ZtPLAZZv6opFVdbgnf9nKxcCpk4a +ahELfrd755jWjHZvwTvbUJN+5dCOHze4vbrGn2zpfDPyMjwmR/onJALJfh1biEIT +ajV8fTXpLmaRcpPVMibEdPVTo7NdmvYJywIDAQABo4HIMIHFMA8GA1UdEwEB/wQF +MAMBAf8wDgYDVR0PAQH/BAQDAgHGMB8GA1UdEQQYMBaBFHBraS1vcHNAdHJ1c3Rk +c3QuY29tMGIGA1UdIARbMFkwVwYKYIZIAWUDAgEBATBJMEcGCCsGAQUFBwIBFjto +dHRwOi8vd3d3LnRydXN0ZHN0LmNvbS9jZXJ0aWZpY2F0ZXMvcG9saWN5L0FDRVMt +aW5kZXguaHRtbDAdBgNVHQ4EFgQUCXIGThhDD+XWzMNqizF7eI+og7gwDQYJKoZI +hvcNAQEFBQADggEBAKPYjtay284F5zLNAdMEA+V25FYrnJmQ6AgwbN99Pe7lv7Uk +QIRJ4dEorsTCOlMwiPH1d25Ryvr/ma8kXxug/fKshMrfqfBfBC6tFr8hlxCBPeP/ +h40y3JTlR4peahPJlJU90u7INJXQgNStMgiAVDzgvVJT11J8smk/f3rPanTK+gQq +nExaBqXpIK1FZg9p8d2/6eMyi/rgwYZNcjwu2JN4Cir42NInPRmJX1p7ijvMDNpR +rscL9yuwNwXsvFcj4jjSm2jzVhKIT0J8uDHEtdvkyCE06UgRNe76x5JXxZ805Mf2 +9w4LTJxoeHtxMcfrHuBnQfO3oKfN5XozNmr6mis= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDSjCCAjKgAwIBAgIQRK+wgNajJ7qJMDmGLvhAazANBgkqhkiG9w0BAQUFADA/ +MSQwIgYDVQQKExtEaWdpdGFsIFNpZ25hdHVyZSBUcnVzdCBDby4xFzAVBgNVBAMT +DkRTVCBSb290IENBIFgzMB4XDTAwMDkzMDIxMTIxOVoXDTIxMDkzMDE0MDExNVow +PzEkMCIGA1UEChMbRGlnaXRhbCBTaWduYXR1cmUgVHJ1c3QgQ28uMRcwFQYDVQQD +Ew5EU1QgUm9vdCBDQSBYMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +AN+v6ZdQCINXtMxiZfaQguzH0yxrMMpb7NnDfcdAwRgUi+DoM3ZJKuM/IUmTrE4O +rz5Iy2Xu/NMhD2XSKtkyj4zl93ewEnu1lcCJo6m67XMuegwGMoOifooUMM0RoOEq +OLl5CjH9UL2AZd+3UWODyOKIYepLYYHsUmu5ouJLGiifSKOeDNoJjj4XLh7dIN9b +xiqKqy69cK3FCxolkHRyxXtqqzTWMIn/5WgTe1QLyNau7Fqckh49ZLOMxt+/yUFw +7BZy1SbsOFU5Q9D8/RhcQPGX69Wam40dutolucbY38EVAjqr2m7xPi71XAicPNaD +aeQQmxkqtilX4+U9m5/wAl0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNV +HQ8BAf8EBAMCAQYwHQYDVR0OBBYEFMSnsaR7LHH62+FLkHX/xBVghYkQMA0GCSqG +SIb3DQEBBQUAA4IBAQCjGiybFwBcqR7uKGY3Or+Dxz9LwwmglSBd49lZRNI+DT69 +ikugdB/OEIKcdBodfpga3csTS7MgROSR6cz8faXbauX+5v3gTt23ADq1cEmv8uXr +AvHRAosZy5Q6XkjEGB5YGV8eAlrwDPGxrancWYaLbumR9YbK+rlmM6pZW87ipxZz +R8srzJmwN0jP41ZL9c8PDHIyh8bwRLtTcm1D9SZImlJnt1ir/md2cXjbDaJWFBM5 +JDGFoqgCWjBH4d1QB7wCCZAA62RjYJsWvIjJEubSfZGL+T0yjWW06XyxV3bqxbYo +Ob8VZRzI9neWagqNdwvYkQsEjgfbKbYK7p2CNTUQ +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDnzCCAoegAwIBAgIBJjANBgkqhkiG9w0BAQUFADBxMQswCQYDVQQGEwJERTEc +MBoGA1UEChMTRGV1dHNjaGUgVGVsZWtvbSBBRzEfMB0GA1UECxMWVC1UZWxlU2Vj +IFRydXN0IENlbnRlcjEjMCEGA1UEAxMaRGV1dHNjaGUgVGVsZWtvbSBSb290IENB +IDIwHhcNOTkwNzA5MTIxMTAwWhcNMTkwNzA5MjM1OTAwWjBxMQswCQYDVQQGEwJE +RTEcMBoGA1UEChMTRGV1dHNjaGUgVGVsZWtvbSBBRzEfMB0GA1UECxMWVC1UZWxl +U2VjIFRydXN0IENlbnRlcjEjMCEGA1UEAxMaRGV1dHNjaGUgVGVsZWtvbSBSb290 +IENBIDIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCrC6M14IspFLEU +ha88EOQ5bzVdSq7d6mGNlUn0b2SjGmBmpKlAIoTZ1KXleJMOaAGtuU1cOs7TuKhC +QN/Po7qCWWqSG6wcmtoIKyUn+WkjR/Hg6yx6m/UTAtB+NHzCnjwAWav12gz1Mjwr +rFDa1sPeg5TKqAyZMg4ISFZbavva4VhYAUlfckE8FQYBjl2tqriTtM2e66foai1S +NNs671x1Udrb8zH57nGYMsRUFUQM+ZtV7a3fGAigo4aKSe5TBY8ZTNXeWHmb0moc +QqvF1afPaA+W5OFhmHZhyJF81j4A4pFQh+GdCuatl9Idxjp9y7zaAzTVjlsB9WoH +txa2bkp/AgMBAAGjQjBAMB0GA1UdDgQWBBQxw3kbuvVT1xfgiXotF2wKsyudMzAP +BgNVHRMECDAGAQH/AgEFMA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQUFAAOC +AQEAlGRZrTlk5ynrE/5aw4sTV8gEJPB0d8Bg42f76Ymmg7+Wgnxu1MM9756Abrsp +tJh6sTtU6zkXR34ajgv8HzFZMQSyzhfzLMdiNlXiItiJVbSYSKpk+tYcNthEeFpa +IzpXl/V6ME+un2pMSyuOoAPjPuCp1NJ70rOo4nI8rZ7/gFnkm0W09juwzTkZmDLl +6iFhkOQxIY40sfcvNUqFENrnijchvllj4PKFiDFT1FQUhXB59C4Gdyd1Lx+4ivn+ +xbrYNuSD7Odlt79jWvNGr4GUN9RBjNYj1h7P9WgbRGOiWrqnNVmh5XAFmw4jV5mU +Cm26OWMohpLzGITY+9HPBVZkVw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDtzCCAp+gAwIBAgIQDOfg5RfYRv6P5WD8G/AwOTANBgkqhkiG9w0BAQUFADBl +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJv +b3QgQ0EwHhcNMDYxMTEwMDAwMDAwWhcNMzExMTEwMDAwMDAwWjBlMQswCQYDVQQG +EwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNl +cnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgQ0EwggEi +MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCtDhXO5EOAXLGH87dg+XESpa7c +JpSIqvTO9SA5KFhgDPiA2qkVlTJhPLWxKISKityfCgyDF3qPkKyK53lTXDGEKvYP +mDI2dsze3Tyoou9q+yHyUmHfnyDXH+Kx2f4YZNISW1/5WBg1vEfNoTb5a3/UsDg+ +wRvDjDPZ2C8Y/igPs6eD1sNuRMBhNZYW/lmci3Zt1/GiSw0r/wty2p5g0I6QNcZ4 +VYcgoc/lbQrISXwxmDNsIumH0DJaoroTghHtORedmTpyoeb6pNnVFzF1roV9Iq4/ +AUaG9ih5yLHa5FcXxH4cDrC0kqZWs72yl+2qp/C3xag/lRbQ/6GW6whfGHdPAgMB +AAGjYzBhMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW +BBRF66Kv9JLLgjEtUYunpyGd823IDzAfBgNVHSMEGDAWgBRF66Kv9JLLgjEtUYun +pyGd823IDzANBgkqhkiG9w0BAQUFAAOCAQEAog683+Lt8ONyc3pklL/3cmbYMuRC +dWKuh+vy1dneVrOfzM4UKLkNl2BcEkxY5NM9g0lFWJc1aRqoR+pWxnmrEthngYTf +fwk8lOa4JiwgvT2zKIn3X/8i4peEH+ll74fg38FnSbNd67IJKusm7Xi+fT8r87cm +NW1fiQG2SVufAQWbqz0lwcy2f8Lxb4bG+mRo64EtlOtCt/qMHt1i8b5QZ7dsvfPx +H2sMNgcWfzd8qVttevESRmCD1ycEvkvOl77DZypoEd+A5wwzZr8TDRRu838fYxAe ++o0bJW1sj6W3YQGx0qMmoRBxna3iw/nDmVG3KwcIzi7mULKn+gpFL6Lw8g== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDljCCAn6gAwIBAgIQC5McOtY5Z+pnI7/Dr5r0SzANBgkqhkiG9w0BAQsFADBl +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJv +b3QgRzIwHhcNMTMwODAxMTIwMDAwWhcNMzgwMTE1MTIwMDAwWjBlMQswCQYDVQQG +EwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNl +cnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgRzIwggEi +MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDZ5ygvUj82ckmIkzTz+GoeMVSA +n61UQbVH35ao1K+ALbkKz3X9iaV9JPrjIgwrvJUXCzO/GU1BBpAAvQxNEP4Htecc +biJVMWWXvdMX0h5i89vqbFCMP4QMls+3ywPgym2hFEwbid3tALBSfK+RbLE4E9Hp +EgjAALAcKxHad3A2m67OeYfcgnDmCXRwVWmvo2ifv922ebPynXApVfSr/5Vh88lA +bx3RvpO704gqu52/clpWcTs/1PPRCv4o76Pu2ZmvA9OPYLfykqGxvYmJHzDNw6Yu +YjOuFgJ3RFrngQo8p0Quebg/BLxcoIfhG69Rjs3sLPr4/m3wOnyqi+RnlTGNAgMB +AAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQW +BBTOw0q5mVXyuNtgv6l+vVa1lzan1jANBgkqhkiG9w0BAQsFAAOCAQEAyqVVjOPI +QW5pJ6d1Ee88hjZv0p3GeDgdaZaikmkuOGybfQTUiaWxMTeKySHMq2zNixya1r9I +0jJmwYrA8y8678Dj1JGG0VDjA9tzd29KOVPt3ibHtX2vK0LRdWLjSisCx1BL4Gni +lmwORGYQRI+tBev4eaymG+g3NJ1TyWGqolKvSnAWhsI6yLETcDbYz+70CjTVW0z9 +B5yiutkBclzzTcHdDrEcDcRjvq30FPuJ7KJBDkzMyFdA0G4Dqs0MjomZmWzwPDCv +ON9vvKO+KSAnq3T/EyJ43pdSVR6DtVQgA+6uwE9W3jfMw3+qBCe703e4YtsXfJwo +IhNzbM8m9Yop5w== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICRjCCAc2gAwIBAgIQC6Fa+h3foLVJRK/NJKBs7DAKBggqhkjOPQQDAzBlMQsw +CQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cu +ZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3Qg +RzMwHhcNMTMwODAxMTIwMDAwWhcNMzgwMTE1MTIwMDAwWjBlMQswCQYDVQQGEwJV +UzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNlcnQu +Y29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgRzMwdjAQBgcq +hkjOPQIBBgUrgQQAIgNiAAQZ57ysRGXtzbg/WPuNsVepRC0FFfLvC/8QdJ+1YlJf +Zn4f5dwbRXkLzMZTCp2NXQLZqVneAlr2lSoOjThKiknGvMYDOAdfVdp+CW7if17Q +RSAPWXYQ1qAk8C3eNvJsKTmjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/ +BAQDAgGGMB0GA1UdDgQWBBTL0L2p4ZgFUaFNN6KDec6NHSrkhDAKBggqhkjOPQQD +AwNnADBkAjAlpIFFAmsSS3V0T8gj43DydXLefInwz5FyYZ5eEJJZVrmDxxDnOOlY +JjZ91eQ0hjkCMHw2U/Aw5WJjOpnitqM7mzT6HtoQknFekROn3aRukswy1vUhZscv +6pZjamVFkpUBtA== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDrzCCApegAwIBAgIQCDvgVpBCRrGhdWrJWZHHSjANBgkqhkiG9w0BAQUFADBh +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBD +QTAeFw0wNjExMTAwMDAwMDBaFw0zMTExMTAwMDAwMDBaMGExCzAJBgNVBAYTAlVT +MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j +b20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IENBMIIBIjANBgkqhkiG +9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4jvhEXLeqKTTo1eqUKKPC3eQyaKl7hLOllsB +CSDMAZOnTjC3U/dDxGkAV53ijSLdhwZAAIEJzs4bg7/fzTtxRuLWZscFs3YnFo97 +nh6Vfe63SKMI2tavegw5BmV/Sl0fvBf4q77uKNd0f3p4mVmFaG5cIzJLv07A6Fpt +43C/dxC//AH2hdmoRBBYMql1GNXRor5H4idq9Joz+EkIYIvUX7Q6hL+hqkpMfT7P +T19sdl6gSzeRntwi5m3OFBqOasv+zbMUZBfHWymeMr/y7vrTC0LUq7dBMtoM1O/4 +gdW7jVg/tRvoSSiicNoxBN33shbyTApOB6jtSj1etX+jkMOvJwIDAQABo2MwYTAO +BgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA95QNVbR +TLtm8KPiGxvDl7I90VUwHwYDVR0jBBgwFoAUA95QNVbRTLtm8KPiGxvDl7I90VUw +DQYJKoZIhvcNAQEFBQADggEBAMucN6pIExIK+t1EnE9SsPTfrgT1eXkIoyQY/Esr +hMAtudXH/vTBH1jLuG2cenTnmCmrEbXjcKChzUyImZOMkXDiqw8cvpOp/2PV5Adg +06O/nVsJ8dWO41P0jmP6P6fbtGbfYmbW0W5BjfIttep3Sp+dWOIrWcBAI+0tKIJF +PnlUkiaY4IBIqDfv8NZ5YBberOgOzW6sRBc4L0na4UU+Krk2U886UAb3LujEV0ls +YSEY1QSteDwsOoBrp+uvFRTp2InBuThs4pFsiv9kuXclVzDAGySj4dzp30d8tbQk +CAUw7C29C79Fv1C5qfPrmAESrciIxpg0X40KPMbp1ZWVbd4= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDjjCCAnagAwIBAgIQAzrx5qcRqaC7KGSxHQn65TANBgkqhkiG9w0BAQsFADBh +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBH +MjAeFw0xMzA4MDExMjAwMDBaFw0zODAxMTUxMjAwMDBaMGExCzAJBgNVBAYTAlVT +MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j +b20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IEcyMIIBIjANBgkqhkiG +9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuzfNNNx7a8myaJCtSnX/RrohCgiN9RlUyfuI +2/Ou8jqJkTx65qsGGmvPrC3oXgkkRLpimn7Wo6h+4FR1IAWsULecYxpsMNzaHxmx +1x7e/dfgy5SDN67sH0NO3Xss0r0upS/kqbitOtSZpLYl6ZtrAGCSYP9PIUkY92eQ +q2EGnI/yuum06ZIya7XzV+hdG82MHauVBJVJ8zUtluNJbd134/tJS7SsVQepj5Wz +tCO7TG1F8PapspUwtP1MVYwnSlcUfIKdzXOS0xZKBgyMUNGPHgm+F6HmIcr9g+UQ +vIOlCsRnKPZzFBQ9RnbDhxSJITRNrw9FDKZJobq7nMWxM4MphQIDAQABo0IwQDAP +BgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAdBgNVHQ4EFgQUTiJUIBiV +5uNu5g/6+rkS7QYXjzkwDQYJKoZIhvcNAQELBQADggEBAGBnKJRvDkhj6zHd6mcY +1Yl9PMWLSn/pvtsrF9+wX3N3KjITOYFnQoQj8kVnNeyIv/iPsGEMNKSuIEyExtv4 +NeF22d+mQrvHRAiGfzZ0JFrabA0UWTW98kndth/Jsw1HKj2ZL7tcu7XUIOGZX1NG +Fdtom/DzMNU+MeKNhJ7jitralj41E6Vf8PlwUHBHQRFXGU7Aj64GxJUTFy8bJZ91 +8rGOmaFvE7FBcf6IKshPECBV1/MUReXgRPTqh5Uykw7+U0b6LJ3/iyK5S9kJRaTe +pLiaWN0bfVKfjllDiIGknibVb63dDcY3fe0Dkhvld1927jyNxF1WW6LZZm6zNTfl +MrY= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICPzCCAcWgAwIBAgIQBVVWvPJepDU1w6QP1atFcjAKBggqhkjOPQQDAzBhMQsw +CQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cu +ZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBHMzAe +Fw0xMzA4MDExMjAwMDBaFw0zODAxMTUxMjAwMDBaMGExCzAJBgNVBAYTAlVTMRUw +EwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5jb20x +IDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IEczMHYwEAYHKoZIzj0CAQYF +K4EEACIDYgAE3afZu4q4C/sLfyHS8L6+c/MzXRq8NOrexpu80JX28MzQC7phW1FG +fp4tn+6OYwwX7Adw9c+ELkCDnOg/QW07rdOkFFk2eJ0DQ+4QE2xy3q6Ip6FrtUPO +Z9wj/wMco+I+o0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAd +BgNVHQ4EFgQUs9tIpPmhxdiuNkHMEWNpYim8S8YwCgYIKoZIzj0EAwMDaAAwZQIx +AK288mw/EkrRLTnDCgmXc/SINoyIJ7vmiI1Qhadj+Z4y3maTD/HMsQmP3Wyr+mt/ +oAIwOWZbwmSNuJ5Q3KjVSaLtx9zRSX8XAbjIho9OjIgrqJqpisXRAL34VOKa5Vt8 +sycX +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDxTCCAq2gAwIBAgIQAqxcJmoLQJuPC3nyrkYldzANBgkqhkiG9w0BAQUFADBs +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSswKQYDVQQDEyJEaWdpQ2VydCBIaWdoIEFzc3VyYW5j +ZSBFViBSb290IENBMB4XDTA2MTExMDAwMDAwMFoXDTMxMTExMDAwMDAwMFowbDEL +MAkGA1UEBhMCVVMxFTATBgNVBAoTDERpZ2lDZXJ0IEluYzEZMBcGA1UECxMQd3d3 +LmRpZ2ljZXJ0LmNvbTErMCkGA1UEAxMiRGlnaUNlcnQgSGlnaCBBc3N1cmFuY2Ug +RVYgUm9vdCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMbM5XPm ++9S75S0tMqbf5YE/yc0lSbZxKsPVlDRnogocsF9ppkCxxLeyj9CYpKlBWTrT3JTW +PNt0OKRKzE0lgvdKpVMSOO7zSW1xkX5jtqumX8OkhPhPYlG++MXs2ziS4wblCJEM +xChBVfvLWokVfnHoNb9Ncgk9vjo4UFt3MRuNs8ckRZqnrG0AFFoEt7oT61EKmEFB +Ik5lYYeBQVCmeVyJ3hlKV9Uu5l0cUyx+mM0aBhakaHPQNAQTXKFx01p8VdteZOE3 +hzBWBOURtCmAEvF5OYiiAhF8J2a3iLd48soKqDirCmTCv2ZdlYTBoSUeh10aUAsg +EsxBu24LUTi4S8sCAwEAAaNjMGEwDgYDVR0PAQH/BAQDAgGGMA8GA1UdEwEB/wQF +MAMBAf8wHQYDVR0OBBYEFLE+w2kD+L9HAdSYJhoIAu9jZCvDMB8GA1UdIwQYMBaA +FLE+w2kD+L9HAdSYJhoIAu9jZCvDMA0GCSqGSIb3DQEBBQUAA4IBAQAcGgaX3Nec +nzyIZgYIVyHbIUf4KmeqvxgydkAQV8GK83rZEWWONfqe/EW1ntlMMUu4kehDLI6z +eM7b41N5cdblIZQB2lWHmiRk9opmzN6cN82oNLFpmyPInngiK3BD41VHMWEZ71jF +hS9OMPagMRYjyOfiZRYzy78aG6A9+MpeizGLYAiJLQwGXFK3xPkKmNEVX58Svnw2 +Yzi9RKR/5CYrCsSXaQ3pjOLAEFe4yHYSkVXySGnYvCoCWw9E1CAx2/S6cCZdkGCe +vEsXCS+0yx5DaMkHJ8HSXPfqIbloEpw8nL+e/IBcm2PN7EeqJSdnoDfzAIJ9VNep ++OkuE6N36B9K +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFkDCCA3igAwIBAgIQBZsbV56OITLiOQe9p3d1XDANBgkqhkiG9w0BAQwFADBi +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSEwHwYDVQQDExhEaWdpQ2VydCBUcnVzdGVkIFJvb3Qg +RzQwHhcNMTMwODAxMTIwMDAwWhcNMzgwMTE1MTIwMDAwWjBiMQswCQYDVQQGEwJV +UzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNlcnQu +Y29tMSEwHwYDVQQDExhEaWdpQ2VydCBUcnVzdGVkIFJvb3QgRzQwggIiMA0GCSqG +SIb3DQEBAQUAA4ICDwAwggIKAoICAQC/5pBzaN675F1KPDAiMGkz7MKnJS7JIT3y +ithZwuEppz1Yq3aaza57G4QNxDAf8xukOBbrVsaXbR2rsnnyyhHS5F/WBTxSD1If +xp4VpX6+n6lXFllVcq9ok3DCsrp1mWpzMpTREEQQLt+C8weE5nQ7bXHiLQwb7iDV +ySAdYyktzuxeTsiT+CFhmzTrBcZe7FsavOvJz82sNEBfsXpm7nfISKhmV1efVFiO +DCu3T6cw2Vbuyntd463JT17lNecxy9qTXtyOj4DatpGYQJB5w3jHtrHEtWoYOAMQ +jdjUN6QuBX2I9YI+EJFwq1WCQTLX2wRzKm6RAXwhTNS8rhsDdV14Ztk6MUSaM0C/ +CNdaSaTC5qmgZ92kJ7yhTzm1EVgX9yRcRo9k98FpiHaYdj1ZXUJ2h4mXaXpI8OCi +EhtmmnTK3kse5w5jrubU75KSOp493ADkRSWJtppEGSt+wJS00mFt6zPZxd9LBADM +fRyVw4/3IbKyEbe7f/LVjHAsQWCqsWMYRJUadmJ+9oCw++hkpjPRiQfhvbfmQ6QY +uKZ3AeEPlAwhHbJUKSWJbOUOUlFHdL4mrLZBdd56rF+NP8m800ERElvlEFDrMcXK +chYiCd98THU/Y+whX8QgUWtvsauGi0/C1kVfnSD8oR7FwI+isX4KJpn15GkvmB0t +9dmpsh3lGwIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB +hjAdBgNVHQ4EFgQU7NfjgtJxXWRM3y5nP+e6mK4cD08wDQYJKoZIhvcNAQEMBQAD +ggIBALth2X2pbL4XxJEbw6GiAI3jZGgPVs93rnD5/ZpKmbnJeFwMDF/k5hQpVgs2 +SV1EY+CtnJYYZhsjDT156W1r1lT40jzBQ0CuHVD1UvyQO7uYmWlrx8GnqGikJ9yd ++SeuMIW59mdNOj6PWTkiU0TryF0Dyu1Qen1iIQqAyHNm0aAFYF/opbSnr6j3bTWc +fFqK1qI4mfN4i/RN0iAL3gTujJtHgXINwBQy7zBZLq7gcfJW5GqXb5JQbZaNaHqa +sjYUegbyJLkJEVDXCLG4iXqEI2FCKeWjzaIgQdfRnGTZ6iahixTXTBmyUEFxPT9N +cCOGDErcgdLMMpSEDQgJlxxPwO5rIHQw0uA5NBCFIRUBCOhVMt5xSdkoF1BN5r5N +0XWs0Mr7QbhDparTwwVETyw2m+L64kW4I1NsBm9nVX9GtUw/bihaeSbSpKhil9Ie +4u1Ki7wb/UdKDd9nZn6yW0HQO+T0O/QEY+nvwlQAUaCKKsnOeMzV6ocEGLPOr0mI +r/OSmbaz5mEP0oUA51Aa5BuVnRmhuZyxm7EAHu/QD09CbMkKvO5D+jpxpchNJqU1 +/YldvIViHTLSoCtU7ZpXwdv6EM8Zt4tKG48BtieVU+i2iW1bvGjUI+iLUaJW+fCm +gKDWHrO8Dw9TdSmq6hN35N6MgSGtBxBHEa2HPQfRdbzP82Z+ +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIGSzCCBDOgAwIBAgIIamg+nFGby1MwDQYJKoZIhvcNAQELBQAwgbIxCzAJBgNV +BAYTAlRSMQ8wDQYDVQQHDAZBbmthcmExQDA+BgNVBAoMN0UtVHXEn3JhIEVCRyBC +aWxpxZ9pbSBUZWtub2xvamlsZXJpIHZlIEhpem1ldGxlcmkgQS7Fni4xJjAkBgNV +BAsMHUUtVHVncmEgU2VydGlmaWthc3lvbiBNZXJrZXppMSgwJgYDVQQDDB9FLVR1 +Z3JhIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTEzMDMwNTEyMDk0OFoXDTIz +MDMwMzEyMDk0OFowgbIxCzAJBgNVBAYTAlRSMQ8wDQYDVQQHDAZBbmthcmExQDA+ +BgNVBAoMN0UtVHXEn3JhIEVCRyBCaWxpxZ9pbSBUZWtub2xvamlsZXJpIHZlIEhp +em1ldGxlcmkgQS7Fni4xJjAkBgNVBAsMHUUtVHVncmEgU2VydGlmaWthc3lvbiBN +ZXJrZXppMSgwJgYDVQQDDB9FLVR1Z3JhIENlcnRpZmljYXRpb24gQXV0aG9yaXR5 +MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA4vU/kwVRHoViVF56C/UY +B4Oufq9899SKa6VjQzm5S/fDxmSJPZQuVIBSOTkHS0vdhQd2h8y/L5VMzH2nPbxH +D5hw+IyFHnSOkm0bQNGZDbt1bsipa5rAhDGvykPL6ys06I+XawGb1Q5KCKpbknSF +Q9OArqGIW66z6l7LFpp3RMih9lRozt6Plyu6W0ACDGQXwLWTzeHxE2bODHnv0ZEo +q1+gElIwcxmOj+GMB6LDu0rw6h8VqO4lzKRG+Bsi77MOQ7osJLjFLFzUHPhdZL3D +k14opz8n8Y4e0ypQBaNV2cvnOVPAmJ6MVGKLJrD3fY185MaeZkJVgkfnsliNZvcH +fC425lAcP9tDJMW/hkd5s3kc91r0E+xs+D/iWR+V7kI+ua2oMoVJl0b+SzGPWsut +dEcf6ZG33ygEIqDUD13ieU/qbIWGvaimzuT6w+Gzrt48Ue7LE3wBf4QOXVGUnhMM +ti6lTPk5cDZvlsouDERVxcr6XQKj39ZkjFqzAQqptQpHF//vkUAqjqFGOjGY5RH8 +zLtJVor8udBhmm9lbObDyz51Sf6Pp+KJxWfXnUYTTjF2OySznhFlhqt/7x3U+Lzn +rFpct1pHXFXOVbQicVtbC/DP3KBhZOqp12gKY6fgDT+gr9Oq0n7vUaDmUStVkhUX +U8u3Zg5mTPj5dUyQ5xJwx0UCAwEAAaNjMGEwHQYDVR0OBBYEFC7j27JJ0JxUeVz6 +Jyr+zE7S6E5UMA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAULuPbsknQnFR5 +XPonKv7MTtLoTlQwDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3DQEBCwUAA4ICAQAF +Nzr0TbdF4kV1JI+2d1LoHNgQk2Xz8lkGpD4eKexd0dCrfOAKkEh47U6YA5n+KGCR +HTAduGN8qOY1tfrTYXbm1gdLymmasoR6d5NFFxWfJNCYExL/u6Au/U5Mh/jOXKqY +GwXgAEZKgoClM4so3O0409/lPun++1ndYYRP0lSWE2ETPo+Aab6TR7U1Q9Jauz1c +77NCR807VRMGsAnb/WP2OogKmW9+4c4bU2pEZiNRCHu8W1Ki/QY3OEBhj0qWuJA3 ++GbHeJAAFS6LrVE1Uweoa2iu+U48BybNCAVwzDk/dr2l02cmAYamU9JgO3xDf1WK +vJUawSg5TB9D0pH0clmKuVb8P7Sd2nCcdlqMQ1DujjByTd//SffGqWfZbawCEeI6 +FiWnWAjLb1NBnEg4R2gz0dfHj9R0IdTDBZB6/86WiLEVKV0jq9BgoRJP3vQXzTLl +yb/IQ639Lo7xr+L0mPoSHyDYwKcMhcWQ9DstliaxLL5Mq+ux0orJ23gTDx4JnW2P +AJ8C2sH6H3p6CcRK5ogql5+Ji/03X186zjhZhkuvcQu02PJwT58yE+Owp1fl2tpD +y4Q08ijE6m30Ku/Ba3ba+367hTzSU8JNvnHhRdH9I2cNE3X7z2VnIp2usAnRCf8d +NL/+I5c30jn6PQ0GC7TbO6Orb1wdtn7os4I07QZcJA== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIF5zCCA8+gAwIBAgIITK9zQhyOdAIwDQYJKoZIhvcNAQEFBQAwgYAxODA2BgNV +BAMML0VCRyBFbGVrdHJvbmlrIFNlcnRpZmlrYSBIaXptZXQgU2HEn2xhecSxY8Sx +c8SxMTcwNQYDVQQKDC5FQkcgQmlsacWfaW0gVGVrbm9sb2ppbGVyaSB2ZSBIaXpt +ZXRsZXJpIEEuxZ4uMQswCQYDVQQGEwJUUjAeFw0wNjA4MTcwMDIxMDlaFw0xNjA4 +MTQwMDMxMDlaMIGAMTgwNgYDVQQDDC9FQkcgRWxla3Ryb25payBTZXJ0aWZpa2Eg +SGl6bWV0IFNhxJ9sYXnEsWPEsXPEsTE3MDUGA1UECgwuRUJHIEJpbGnFn2ltIFRl +a25vbG9qaWxlcmkgdmUgSGl6bWV0bGVyaSBBLsWeLjELMAkGA1UEBhMCVFIwggIi +MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDuoIRh0DpqZhAy2DE4f6en5f2h +4fuXd7hxlugTlkaDT7byX3JWbhNgpQGR4lvFzVcfd2NR/y8927k/qqk153nQ9dAk +tiHq6yOU/im/+4mRDGSaBUorzAzu8T2bgmmkTPiab+ci2hC6X5L8GCcKqKpE+i4s +tPtGmggDg3KriORqcsnlZR9uKg+ds+g75AxuetpX/dfreYteIAbTdgtsApWjluTL +dlHRKJ2hGvxEok3MenaoDT2/F08iiFD9rrbskFBKW5+VQarKD7JK/oCZTqNGFav4 +c0JqwmZ2sQomFd2TkuzbqV9UIlKRcF0T6kjsbgNs2d1s/OsNA/+mgxKb8amTD8Um +TDGyY5lhcucqZJnSuOl14nypqZoaqsNW2xCaPINStnuWt6yHd6i58mcLlEOzrz5z ++kI2sSXFCjEmN1ZnuqMLfdb3ic1nobc6HmZP9qBVFCVMLDMNpkGMvQQxahByCp0O +Lna9XvNRiYuoP1Vzv9s6xiQFlpJIqkuNKgPlV5EQ9GooFW5Hd4RcUXSfGenmHmMW +OeMRFeNYGkS9y8RsZteEBt8w9DeiQyJ50hBs37vmExH8nYQKE3vwO9D8owrXieqW +fo1IhR5kX9tUoqzVegJ5a9KK8GfaZXINFHDk6Y54jzJ0fFfy1tb0Nokb+Clsi7n2 +l9GkLqq+CxnCRelwXQIDAJ3Zo2MwYTAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB +/wQEAwIBBjAdBgNVHQ4EFgQU587GT/wWZ5b6SqMHwQSny2re2kcwHwYDVR0jBBgw +FoAU587GT/wWZ5b6SqMHwQSny2re2kcwDQYJKoZIhvcNAQEFBQADggIBAJuYml2+ +8ygjdsZs93/mQJ7ANtyVDR2tFcU22NU57/IeIl6zgrRdu0waypIN30ckHrMk2pGI +6YNw3ZPX6bqz3xZaPt7gyPvT/Wwp+BVGoGgmzJNSroIBk5DKd8pNSe/iWtkqvTDO +TLKBtjDOWU/aWR1qeqRFsIImgYZ29fUQALjuswnoT4cCB64kXPBfrAowzIpAoHME +wfuJJPaaHFy3PApnNgUIMbOv2AFoKuB4j3TeuFGkjGwgPaL7s9QJ/XvCgKqTbCmY +Iai7FvOpEl90tYeY8pUm3zTvilORiF0alKM/fCL414i6poyWqD1SNGKfAB5UVUJn +xk1Gj7sURT0KlhaOEKGXmdXTMIXM3rRyt7yKPBgpaP3ccQfuJDlq+u2lrDgv+R4Q +DgZxGhBM/nV+/x5XOULK1+EVoVZVWRvRo68R2E7DpSvvkL/A7IITW43WciyTTo9q +Kd+FPNMN4KIYEsxVL0e3p5sC/kH2iExt2qkBR4NkJ2IQgtYSe14DHzSpyZH+r11t +hie3I6p1GMog57AP14kOpmciY/SDQSsGS7tY1dHXt7kQY9iJSrSq3RZj9W6+YKH4 +7ejWkE8axsWgKdOnIaj1Wjz3x0miIZpKlVIglnKaZsv30oZDfCK+lvm9AahH3eU7 +QPl1K5srRmSGjR70j/sHd9DqSaIcjVIUpgqT +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFVjCCBD6gAwIBAgIQ7is969Qh3hSoYqwE893EATANBgkqhkiG9w0BAQUFADCB +8zELMAkGA1UEBhMCRVMxOzA5BgNVBAoTMkFnZW5jaWEgQ2F0YWxhbmEgZGUgQ2Vy +dGlmaWNhY2lvIChOSUYgUS0wODAxMTc2LUkpMSgwJgYDVQQLEx9TZXJ2ZWlzIFB1 +YmxpY3MgZGUgQ2VydGlmaWNhY2lvMTUwMwYDVQQLEyxWZWdldSBodHRwczovL3d3 +dy5jYXRjZXJ0Lm5ldC92ZXJhcnJlbCAoYykwMzE1MDMGA1UECxMsSmVyYXJxdWlh +IEVudGl0YXRzIGRlIENlcnRpZmljYWNpbyBDYXRhbGFuZXMxDzANBgNVBAMTBkVD +LUFDQzAeFw0wMzAxMDcyMzAwMDBaFw0zMTAxMDcyMjU5NTlaMIHzMQswCQYDVQQG +EwJFUzE7MDkGA1UEChMyQWdlbmNpYSBDYXRhbGFuYSBkZSBDZXJ0aWZpY2FjaW8g +KE5JRiBRLTA4MDExNzYtSSkxKDAmBgNVBAsTH1NlcnZlaXMgUHVibGljcyBkZSBD +ZXJ0aWZpY2FjaW8xNTAzBgNVBAsTLFZlZ2V1IGh0dHBzOi8vd3d3LmNhdGNlcnQu +bmV0L3ZlcmFycmVsIChjKTAzMTUwMwYDVQQLEyxKZXJhcnF1aWEgRW50aXRhdHMg +ZGUgQ2VydGlmaWNhY2lvIENhdGFsYW5lczEPMA0GA1UEAxMGRUMtQUNDMIIBIjAN +BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsyLHT+KXQpWIR4NA9h0X84NzJB5R +85iKw5K4/0CQBXCHYMkAqbWUZRkiFRfCQ2xmRJoNBD45b6VLeqpjt4pEndljkYRm +4CgPukLjbo73FCeTae6RDqNfDrHrZqJyTxIThmV6PttPB/SnCWDaOkKZx7J/sxaV +HMf5NLWUhdWZXqBIoH7nF2W4onW4HvPlQn2v7fOKSGRdghST2MDk/7NQcvJ29rNd +QlB50JQ+awwAvthrDk4q7D7SzIKiGGUzE3eeml0aE9jD2z3Il3rucO2n5nzbcc8t +lGLfbdb1OL4/pYUKGbio2Al1QnDE6u/LDsg0qBIimAy4E5S2S+zw0JDnJwIDAQAB +o4HjMIHgMB0GA1UdEQQWMBSBEmVjX2FjY0BjYXRjZXJ0Lm5ldDAPBgNVHRMBAf8E +BTADAQH/MA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUoMOLRKo3pUW/l4Ba0fF4 +opvpXY0wfwYDVR0gBHgwdjB0BgsrBgEEAfV4AQMBCjBlMCwGCCsGAQUFBwIBFiBo +dHRwczovL3d3dy5jYXRjZXJ0Lm5ldC92ZXJhcnJlbDA1BggrBgEFBQcCAjApGidW +ZWdldSBodHRwczovL3d3dy5jYXRjZXJ0Lm5ldC92ZXJhcnJlbCAwDQYJKoZIhvcN +AQEFBQADggEBAKBIW4IB9k1IuDlVNZyAelOZ1Vr/sXE7zDkJlF7W2u++AVtd0x7Y +/X1PzaBB4DSTv8vihpw3kpBWHNzrKQXlxJ7HNd+KDM3FIUPpqojlNcAZQmNaAl6k +SBg6hW/cnbw/nZzBh7h6YQjpdwt/cKt63dmXLGQehb+8dJahw3oS7AwaboMMPOhy +Rp/7SNVel+axofjk70YllJyJ22k4vuxcDlbHZVHlUIiIv0LVKz3l+bqeLrPK9HOS +Agu+TGbrIP65y7WZf+a2E/rKS03Z7lNGBjvGTq2TWoF+bCpLagVFjPIhpDGQh2xl +nJ2lYJU6Un/10asIbvPuW/mIPX64b24D5EI= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEAzCCAuugAwIBAgIQVID5oHPtPwBMyonY43HmSjANBgkqhkiG9w0BAQUFADB1 +MQswCQYDVQQGEwJFRTEiMCAGA1UECgwZQVMgU2VydGlmaXRzZWVyaW1pc2tlc2t1 +czEoMCYGA1UEAwwfRUUgQ2VydGlmaWNhdGlvbiBDZW50cmUgUm9vdCBDQTEYMBYG +CSqGSIb3DQEJARYJcGtpQHNrLmVlMCIYDzIwMTAxMDMwMTAxMDMwWhgPMjAzMDEy +MTcyMzU5NTlaMHUxCzAJBgNVBAYTAkVFMSIwIAYDVQQKDBlBUyBTZXJ0aWZpdHNl +ZXJpbWlza2Vza3VzMSgwJgYDVQQDDB9FRSBDZXJ0aWZpY2F0aW9uIENlbnRyZSBS +b290IENBMRgwFgYJKoZIhvcNAQkBFglwa2lAc2suZWUwggEiMA0GCSqGSIb3DQEB +AQUAA4IBDwAwggEKAoIBAQDIIMDs4MVLqwd4lfNE7vsLDP90jmG7sWLqI9iroWUy +euuOF0+W2Ap7kaJjbMeMTC55v6kF/GlclY1i+blw7cNRfdCT5mzrMEvhvH2/UpvO +bntl8jixwKIy72KyaOBhU8E2lf/slLo2rpwcpzIP5Xy0xm90/XsY6KxX7QYgSzIw +WFv9zajmofxwvI6Sc9uXp3whrj3B9UiHbCe9nyV0gVWw93X2PaRka9ZP585ArQ/d +MtO8ihJTmMmJ+xAdTX7Nfh9WDSFwhfYggx/2uh8Ej+p3iDXE/+pOoYtNP2MbRMNE +1CV2yreN1x5KZmTNXMWcg+HCCIia7E6j8T4cLNlsHaFLAgMBAAGjgYowgYcwDwYD +VR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFBLyWj7qVhy/ +zQas8fElyalL1BSZMEUGA1UdJQQ+MDwGCCsGAQUFBwMCBggrBgEFBQcDAQYIKwYB +BQUHAwMGCCsGAQUFBwMEBggrBgEFBQcDCAYIKwYBBQUHAwkwDQYJKoZIhvcNAQEF +BQADggEBAHv25MANqhlHt01Xo/6tu7Fq1Q+e2+RjxY6hUFaTlrg4wCQiZrxTFGGV +v9DHKpY5P30osxBAIWrEr7BSdxjhlthWXePdNl4dp1BUoMUq5KqMlIpPnTX/dqQG +E5Gion0ARD9V04I8GtVbvFZMIi5GQ4okQC3zErg7cBqklrkar4dBGmoYDQZPxz5u +uSlNDUmJEYcyW+ZLBMjkXOZ0c5RdFpgTlf7727FE5TpwrDdr5rMzcijJs1eg9gIW +iAYLtqZLICjU3j2LrTcFU3T+bsy8QxdxXvnFzBqpYe73dgzzcvRyrc9yAjYHR8/v +GVCJYMzpJJUPwssd8m92kMfMdcGWxZ0= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEKjCCAxKgAwIBAgIEOGPe+DANBgkqhkiG9w0BAQUFADCBtDEUMBIGA1UEChML +RW50cnVzdC5uZXQxQDA+BgNVBAsUN3d3dy5lbnRydXN0Lm5ldC9DUFNfMjA0OCBp +bmNvcnAuIGJ5IHJlZi4gKGxpbWl0cyBsaWFiLikxJTAjBgNVBAsTHChjKSAxOTk5 +IEVudHJ1c3QubmV0IExpbWl0ZWQxMzAxBgNVBAMTKkVudHJ1c3QubmV0IENlcnRp +ZmljYXRpb24gQXV0aG9yaXR5ICgyMDQ4KTAeFw05OTEyMjQxNzUwNTFaFw0yOTA3 +MjQxNDE1MTJaMIG0MRQwEgYDVQQKEwtFbnRydXN0Lm5ldDFAMD4GA1UECxQ3d3d3 +LmVudHJ1c3QubmV0L0NQU18yMDQ4IGluY29ycC4gYnkgcmVmLiAobGltaXRzIGxp +YWIuKTElMCMGA1UECxMcKGMpIDE5OTkgRW50cnVzdC5uZXQgTGltaXRlZDEzMDEG +A1UEAxMqRW50cnVzdC5uZXQgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgKDIwNDgp +MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArU1LqRKGsuqjIAcVFmQq +K0vRvwtKTY7tgHalZ7d4QMBzQshowNtTK91euHaYNZOLGp18EzoOH1u3Hs/lJBQe +sYGpjX24zGtLA/ECDNyrpUAkAH90lKGdCCmziAv1h3edVc3kw37XamSrhRSGlVuX +MlBvPci6Zgzj/L24ScF2iUkZ/cCovYmjZy/Gn7xxGWC4LeksyZB2ZnuU4q941mVT +XTzWnLLPKQP5L6RQstRIzgUyVYr9smRMDuSYB3Xbf9+5CFVghTAp+XtIpGmG4zU/ +HoZdenoVve8AjhUiVBcAkCaTvA5JaJG/+EfTnZVCwQ5N328mz8MYIWJmQ3DW1cAH +4QIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNV +HQ4EFgQUVeSB0RGAvtiJuQijMfmhJAkWuXAwDQYJKoZIhvcNAQEFBQADggEBADub +j1abMOdTmXx6eadNl9cZlZD7Bh/KM3xGY4+WZiT6QBshJ8rmcnPyT/4xmf3IDExo +U8aAghOY+rat2l098c5u9hURlIIM7j+VrxGrD9cv3h8Dj1csHsm7mhpElesYT6Yf +zX1XEC+bBAlahLVu2B064dae0Wx5XnkcFMXj0EyTO2U87d89vqbllRrDtRnDvV5b +u/8j72gZyxKTJ1wDLW8w0B62GqzeWvfRqqgnpv55gcR5mTNXuhKwqeBCbJPKVt7+ +bYQLCIt+jerXmCHG8+c8eS9enNFMFY3h7CI3zJpDC5fcgJCNs2ebb0gIFVbPv/Er +fF6adulZkMV8gzURZVE= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIE2DCCBEGgAwIBAgIEN0rSQzANBgkqhkiG9w0BAQUFADCBwzELMAkGA1UEBhMC +VVMxFDASBgNVBAoTC0VudHJ1c3QubmV0MTswOQYDVQQLEzJ3d3cuZW50cnVzdC5u +ZXQvQ1BTIGluY29ycC4gYnkgcmVmLiAobGltaXRzIGxpYWIuKTElMCMGA1UECxMc +KGMpIDE5OTkgRW50cnVzdC5uZXQgTGltaXRlZDE6MDgGA1UEAxMxRW50cnVzdC5u +ZXQgU2VjdXJlIFNlcnZlciBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw05OTA1 +MjUxNjA5NDBaFw0xOTA1MjUxNjM5NDBaMIHDMQswCQYDVQQGEwJVUzEUMBIGA1UE +ChMLRW50cnVzdC5uZXQxOzA5BgNVBAsTMnd3dy5lbnRydXN0Lm5ldC9DUFMgaW5j +b3JwLiBieSByZWYuIChsaW1pdHMgbGlhYi4pMSUwIwYDVQQLExwoYykgMTk5OSBF +bnRydXN0Lm5ldCBMaW1pdGVkMTowOAYDVQQDEzFFbnRydXN0Lm5ldCBTZWN1cmUg +U2VydmVyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIGdMA0GCSqGSIb3DQEBAQUA +A4GLADCBhwKBgQDNKIM0VBuJ8w+vN5Ex/68xYMmo6LIQaO2f55M28Qpku0f1BBc/ +I0dNxScZgSYMVHINiC3ZH5oSn7yzcdOAGT9HZnuMNSjSuQrfJNqc1lB5gXpa0zf3 +wkrYKZImZNHkmGw6AIr1NJtl+O3jEP/9uElY3KDegjlrgbEWGWG5VLbmQwIBA6OC +AdcwggHTMBEGCWCGSAGG+EIBAQQEAwIABzCCARkGA1UdHwSCARAwggEMMIHeoIHb +oIHYpIHVMIHSMQswCQYDVQQGEwJVUzEUMBIGA1UEChMLRW50cnVzdC5uZXQxOzA5 +BgNVBAsTMnd3dy5lbnRydXN0Lm5ldC9DUFMgaW5jb3JwLiBieSByZWYuIChsaW1p +dHMgbGlhYi4pMSUwIwYDVQQLExwoYykgMTk5OSBFbnRydXN0Lm5ldCBMaW1pdGVk +MTowOAYDVQQDEzFFbnRydXN0Lm5ldCBTZWN1cmUgU2VydmVyIENlcnRpZmljYXRp +b24gQXV0aG9yaXR5MQ0wCwYDVQQDEwRDUkwxMCmgJ6AlhiNodHRwOi8vd3d3LmVu +dHJ1c3QubmV0L0NSTC9uZXQxLmNybDArBgNVHRAEJDAigA8xOTk5MDUyNTE2MDk0 +MFqBDzIwMTkwNTI1MTYwOTQwWjALBgNVHQ8EBAMCAQYwHwYDVR0jBBgwFoAU8Bdi +E1U9s/8KAGv7UISX8+1i0BowHQYDVR0OBBYEFPAXYhNVPbP/CgBr+1CEl/PtYtAa +MAwGA1UdEwQFMAMBAf8wGQYJKoZIhvZ9B0EABAwwChsEVjQuMAMCBJAwDQYJKoZI +hvcNAQEFBQADgYEAkNwwAvpkdMKnCqV8IY00F6j7Rw7/JXyNEwr75Ji174z4xRAN +95K+8cPV1ZVqBLssziY2ZcgxxufuP+NXdYR6Ee9GTxj005i7qIcyunL2POI9n9cd +2cNgQ4xYDiKWL2KjLB+6rQXvqzJ4h6BUcxm1XAX5Uj5tLUUL9wqT6u0G+bI= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEkTCCA3mgAwIBAgIERWtQVDANBgkqhkiG9w0BAQUFADCBsDELMAkGA1UEBhMC +VVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xOTA3BgNVBAsTMHd3dy5lbnRydXN0 +Lm5ldC9DUFMgaXMgaW5jb3Jwb3JhdGVkIGJ5IHJlZmVyZW5jZTEfMB0GA1UECxMW +KGMpIDIwMDYgRW50cnVzdCwgSW5jLjEtMCsGA1UEAxMkRW50cnVzdCBSb290IENl +cnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA2MTEyNzIwMjM0MloXDTI2MTEyNzIw +NTM0MlowgbAxCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1FbnRydXN0LCBJbmMuMTkw +NwYDVQQLEzB3d3cuZW50cnVzdC5uZXQvQ1BTIGlzIGluY29ycG9yYXRlZCBieSBy +ZWZlcmVuY2UxHzAdBgNVBAsTFihjKSAyMDA2IEVudHJ1c3QsIEluYy4xLTArBgNV +BAMTJEVudHJ1c3QgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCCASIwDQYJ +KoZIhvcNAQEBBQADggEPADCCAQoCggEBALaVtkNC+sZtKm9I35RMOVcF7sN5EUFo +Nu3s/poBj6E4KPz3EEZmLk0eGrEaTsbRwJWIsMn/MYszA9u3g3s+IIRe7bJWKKf4 +4LlAcTfFy0cOlypowCKVYhXbR9n10Cv/gkvJrT7eTNuQgFA/CYqEAOwwCj0Yzfv9 +KlmaI5UXLEWeH25DeW0MXJj+SKfFI0dcXv1u5x609mhF0YaDW6KKjbHjKYD+JXGI +rb68j6xSlkuqUY3kEzEZ6E5Nn9uss2rVvDlUccp6en+Q3X0dgNmBu1kmwhH+5pPi +94DkZfs0Nw4pgHBNrziGLp5/V6+eF67rHMsoIV+2HNjnogQi+dPa2MsCAwEAAaOB +sDCBrTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zArBgNVHRAEJDAi +gA8yMDA2MTEyNzIwMjM0MlqBDzIwMjYxMTI3MjA1MzQyWjAfBgNVHSMEGDAWgBRo +kORnpKZTgMeGZqTx90tD+4S9bTAdBgNVHQ4EFgQUaJDkZ6SmU4DHhmak8fdLQ/uE +vW0wHQYJKoZIhvZ9B0EABBAwDhsIVjcuMTo0LjADAgSQMA0GCSqGSIb3DQEBBQUA +A4IBAQCT1DCw1wMgKtD5Y+iRDAUgqV8ZyntyTtSx29CW+1RaGSwMCPeyvIWonX9t +O1KzKtvn1ISMY/YPyyYBkVBs9F8U4pN0wBOeMDpQ47RgxRzwIkSNcUesyBrJ6Zua +AGAT/3B+XxFNSRuzFVJ7yVTav52Vr2ua2J7p8eRDjeIRRDq/r72DQnNSi6q7pynP +9WQcCk3RvKqsnyrQ/39/2n3qse0wJcGE2jTSW3iDVuycNsMm4hH2Z0kdkquM++v/ +eu6FSqdQgPCnXEqULl8FmTxSQeDNtGPPAUO6nIPcj2A781q0tHuu2guQOHXvgR1m +0vdXcDazv/wor3ElhVsT/h5/WrQ8 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIC+TCCAoCgAwIBAgINAKaLeSkAAAAAUNCR+TAKBggqhkjOPQQDAzCBvzELMAkG +A1UEBhMCVVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xKDAmBgNVBAsTH1NlZSB3 +d3cuZW50cnVzdC5uZXQvbGVnYWwtdGVybXMxOTA3BgNVBAsTMChjKSAyMDEyIEVu +dHJ1c3QsIEluYy4gLSBmb3IgYXV0aG9yaXplZCB1c2Ugb25seTEzMDEGA1UEAxMq +RW50cnVzdCBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IC0gRUMxMB4XDTEy +MTIxODE1MjUzNloXDTM3MTIxODE1NTUzNlowgb8xCzAJBgNVBAYTAlVTMRYwFAYD +VQQKEw1FbnRydXN0LCBJbmMuMSgwJgYDVQQLEx9TZWUgd3d3LmVudHJ1c3QubmV0 +L2xlZ2FsLXRlcm1zMTkwNwYDVQQLEzAoYykgMjAxMiBFbnRydXN0LCBJbmMuIC0g +Zm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxMzAxBgNVBAMTKkVudHJ1c3QgUm9vdCBD +ZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEVDMTB2MBAGByqGSM49AgEGBSuBBAAi +A2IABIQTydC6bUF74mzQ61VfZgIaJPRbiWlH47jCffHyAsWfoPZb1YsGGYZPUxBt +ByQnoaD41UcZYUx9ypMn6nQM72+WCf5j7HBdNq1nd67JnXxVRDqiY1Ef9eNi1KlH +Bz7MIKNCMEAwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0O +BBYEFLdj5xrdjekIplWDpOBqUEFlEUJJMAoGCCqGSM49BAMDA2cAMGQCMGF52OVC +R98crlOZF7ZvHH3hvxGU0QOIdeSNiaSKd0bebWHvAvX7td/M/k7//qnmpwIwW5nX +hTcGtXsI/esni0qU+eH6p44mCOh8kmhtc9hvJqwhAriZtyZBWyVgrtBIGu4G +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEPjCCAyagAwIBAgIESlOMKDANBgkqhkiG9w0BAQsFADCBvjELMAkGA1UEBhMC +VVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xKDAmBgNVBAsTH1NlZSB3d3cuZW50 +cnVzdC5uZXQvbGVnYWwtdGVybXMxOTA3BgNVBAsTMChjKSAyMDA5IEVudHJ1c3Qs +IEluYy4gLSBmb3IgYXV0aG9yaXplZCB1c2Ugb25seTEyMDAGA1UEAxMpRW50cnVz +dCBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IC0gRzIwHhcNMDkwNzA3MTcy +NTU0WhcNMzAxMjA3MTc1NTU0WjCBvjELMAkGA1UEBhMCVVMxFjAUBgNVBAoTDUVu +dHJ1c3QsIEluYy4xKDAmBgNVBAsTH1NlZSB3d3cuZW50cnVzdC5uZXQvbGVnYWwt +dGVybXMxOTA3BgNVBAsTMChjKSAyMDA5IEVudHJ1c3QsIEluYy4gLSBmb3IgYXV0 +aG9yaXplZCB1c2Ugb25seTEyMDAGA1UEAxMpRW50cnVzdCBSb290IENlcnRpZmlj +YXRpb24gQXV0aG9yaXR5IC0gRzIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK +AoIBAQC6hLZy254Ma+KZ6TABp3bqMriVQRrJ2mFOWHLP/vaCeb9zYQYKpSfYs1/T +RU4cctZOMvJyig/3gxnQaoCAAEUesMfnmr8SVycco2gvCoe9amsOXmXzHHfV1IWN +cCG0szLni6LVhjkCsbjSR87kyUnEO6fe+1R9V77w6G7CebI6C1XiUJgWMhNcL3hW +wcKUs/Ja5CeanyTXxuzQmyWC48zCxEXFjJd6BmsqEZ+pCm5IO2/b1BEZQvePB7/1 +U1+cPvQXLOZprE4yTGJ36rfo5bs0vBmLrpxR57d+tVOxMyLlbc9wPBr64ptntoP0 +jaWvYkxN4FisZDQSA/i2jZRjJKRxAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAP +BgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRqciZ60B7vfec7aVHUbI2fkBJmqzAN +BgkqhkiG9w0BAQsFAAOCAQEAeZ8dlsa2eT8ijYfThwMEYGprmi5ZiXMRrEPR9RP/ +jTkrwPK9T3CMqS/qF8QLVJ7UG5aYMzyorWKiAHarWWluBh1+xLlEjZivEtRh2woZ +Rkfz6/djwUAFQKXSt/S1mja/qYh2iARVBCuch38aNzx+LaUa2NSJXsq9rD1s2G2v +1fN2D807iDginWyTmsQ9v4IbZT+mD12q/OWyFcq1rca8PdCE6OoGcrBNOTJ4vz4R +nAuknZoh8/CbCzB428Hch0P+vGOaysXCHMnHjf87ElgI5rY97HosTvuDls4MPGmH +VHOkc8KT/1EQrBVUAdj8BbGJoX90g5pJ19xOe4pIb4tF9g== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDIDCCAomgAwIBAgIENd70zzANBgkqhkiG9w0BAQUFADBOMQswCQYDVQQGEwJV +UzEQMA4GA1UEChMHRXF1aWZheDEtMCsGA1UECxMkRXF1aWZheCBTZWN1cmUgQ2Vy +dGlmaWNhdGUgQXV0aG9yaXR5MB4XDTk4MDgyMjE2NDE1MVoXDTE4MDgyMjE2NDE1 +MVowTjELMAkGA1UEBhMCVVMxEDAOBgNVBAoTB0VxdWlmYXgxLTArBgNVBAsTJEVx +dWlmYXggU2VjdXJlIENlcnRpZmljYXRlIEF1dGhvcml0eTCBnzANBgkqhkiG9w0B +AQEFAAOBjQAwgYkCgYEAwV2xWGcIYu6gmi0fCG2RFGiYCh7+2gRvE4RiIcPRfM6f +BeC4AfBONOziipUEZKzxa1NfBbPLZ4C/QgKO/t0BCezhABRP/PvwDN1Dulsr4R+A +cJkVV5MW8Q+XarfCaCMczE1ZMKxRHjuvK9buY0V7xdlfUNLjUA86iOe/FP3gx7kC +AwEAAaOCAQkwggEFMHAGA1UdHwRpMGcwZaBjoGGkXzBdMQswCQYDVQQGEwJVUzEQ +MA4GA1UEChMHRXF1aWZheDEtMCsGA1UECxMkRXF1aWZheCBTZWN1cmUgQ2VydGlm +aWNhdGUgQXV0aG9yaXR5MQ0wCwYDVQQDEwRDUkwxMBoGA1UdEAQTMBGBDzIwMTgw +ODIyMTY0MTUxWjALBgNVHQ8EBAMCAQYwHwYDVR0jBBgwFoAUSOZo+SvSspXXR9gj +IBBPM5iQn9QwHQYDVR0OBBYEFEjmaPkr0rKV10fYIyAQTzOYkJ/UMAwGA1UdEwQF +MAMBAf8wGgYJKoZIhvZ9B0EABA0wCxsFVjMuMGMDAgbAMA0GCSqGSIb3DQEBBQUA +A4GBAFjOKer89961zgK5F7WF0bnj4JXMJTENAKaSbn+2kmOeUJXRmm/kEd5jhW6Y +7qj/WsjTVbJmcVfewCHrPSqnI0kBBIZCe/zuf6IWUrVnZ9NA2zsmWLIodz2uFHdh +1voqZiegDfqnc1zqcPGUIWVEX/r87yloqaKHee9570+sB3c4 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICkDCCAfmgAwIBAgIBATANBgkqhkiG9w0BAQQFADBaMQswCQYDVQQGEwJVUzEc +MBoGA1UEChMTRXF1aWZheCBTZWN1cmUgSW5jLjEtMCsGA1UEAxMkRXF1aWZheCBT +ZWN1cmUgR2xvYmFsIGVCdXNpbmVzcyBDQS0xMB4XDTk5MDYyMTA0MDAwMFoXDTIw +MDYyMTA0MDAwMFowWjELMAkGA1UEBhMCVVMxHDAaBgNVBAoTE0VxdWlmYXggU2Vj +dXJlIEluYy4xLTArBgNVBAMTJEVxdWlmYXggU2VjdXJlIEdsb2JhbCBlQnVzaW5l +c3MgQ0EtMTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAuucXkAJlsTRVPEnC +UdXfp9E3j9HngXNBUmCbnaEXJnitx7HoJpQytd4zjTov2/KaelpzmKNc6fuKcxtc +58O/gGzNqfTWK8D3+ZmqY6KxRwIP1ORROhI8bIpaVIRw28HFkM9yRcuoWcDNM50/ +o5brhTMhHD4ePmBudpxnhcXIw2ECAwEAAaNmMGQwEQYJYIZIAYb4QgEBBAQDAgAH +MA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAUvqigdHJQa0S3ySPY+6j/s1dr +aGwwHQYDVR0OBBYEFL6ooHRyUGtEt8kj2Puo/7NXa2hsMA0GCSqGSIb3DQEBBAUA +A4GBADDiAVGqx+pf2rnQZQ8w1j7aDRRJbpGTJxQx78T3LUX47Me/okENI7SS+RkA +Z70Br83gcfxaz2TE4JaY0KNA4gGK7ycH8WUBikQtBmV1UsCGECAhX2xrD2yuCRyv +8qIYNMR1pHMc8Y3c7635s3a0kr/clRAevsvIO1qEYBlWlKlV +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICgjCCAeugAwIBAgIBBDANBgkqhkiG9w0BAQQFADBTMQswCQYDVQQGEwJVUzEc +MBoGA1UEChMTRXF1aWZheCBTZWN1cmUgSW5jLjEmMCQGA1UEAxMdRXF1aWZheCBT +ZWN1cmUgZUJ1c2luZXNzIENBLTEwHhcNOTkwNjIxMDQwMDAwWhcNMjAwNjIxMDQw +MDAwWjBTMQswCQYDVQQGEwJVUzEcMBoGA1UEChMTRXF1aWZheCBTZWN1cmUgSW5j +LjEmMCQGA1UEAxMdRXF1aWZheCBTZWN1cmUgZUJ1c2luZXNzIENBLTEwgZ8wDQYJ +KoZIhvcNAQEBBQADgY0AMIGJAoGBAM4vGbwXt3fek6lfWg0XTzQaDJj0ItlZ1MRo +RvC0NcWFAyDGr0WlIVFFQesWWDYyb+JQYmT5/VGcqiTZ9J2DKocKIdMSODRsjQBu +WqDZQu4aIZX5UkxVWsUPOE9G+m34LjXWHXzr4vCwdYDIqROsvojvOm6rXyo4YgKw +Env+j6YDAgMBAAGjZjBkMBEGCWCGSAGG+EIBAQQEAwIABzAPBgNVHRMBAf8EBTAD +AQH/MB8GA1UdIwQYMBaAFEp4MlIR21kWNl7fwRQ2QGpHfEyhMB0GA1UdDgQWBBRK +eDJSEdtZFjZe38EUNkBqR3xMoTANBgkqhkiG9w0BAQQFAAOBgQB1W6ibAxHm6VZM +zfmpTMANmvPMZWnmJXbMWbfWVMMdzZmsGd20hdXgPfxiIKeES1hl8eL5lSE/9dR+ +WB5Hh1Q+WKG1tfgq73HnvMP2sUlG4tega+VWeponmHxGYhTnyfxuAxJ5gDgdSIKN +/Bf+KpYrtWKmpj29f5JZzVoqgrI3eQ== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICWjCCAcMCAgGlMA0GCSqGSIb3DQEBBAUAMHUxCzAJBgNVBAYTAlVTMRgwFgYD +VQQKEw9HVEUgQ29ycG9yYXRpb24xJzAlBgNVBAsTHkdURSBDeWJlclRydXN0IFNv +bHV0aW9ucywgSW5jLjEjMCEGA1UEAxMaR1RFIEN5YmVyVHJ1c3QgR2xvYmFsIFJv +b3QwHhcNOTgwODEzMDAyOTAwWhcNMTgwODEzMjM1OTAwWjB1MQswCQYDVQQGEwJV +UzEYMBYGA1UEChMPR1RFIENvcnBvcmF0aW9uMScwJQYDVQQLEx5HVEUgQ3liZXJU +cnVzdCBTb2x1dGlvbnMsIEluYy4xIzAhBgNVBAMTGkdURSBDeWJlclRydXN0IEds +b2JhbCBSb290MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCVD6C28FCc6HrH +iM3dFw4usJTQGz0O9pTAipTHBsiQl8i4ZBp6fmw8U+E3KHNgf7KXUwefU/ltWJTS +r41tiGeA5u2ylc9yMcqlHHK6XALnZELn+aks1joNrI1CqiQBOeacPwGFVw1Yh0X4 +04Wqk2kmhXBIgD8SFcd5tB8FLztimQIDAQABMA0GCSqGSIb3DQEBBAUAA4GBAG3r +GwnpXtlR22ciYaQqPEh346B8pt5zohQDhT37qw4wxYMWM4ETCJ57NE7fQMh017l9 +3PR2VX2bY1QY6fDq81yx2YtCHrnAlU66+tXifPVoYb+O7AWXX1uw16OFNMQkpw0P +lZPvy5TYnh+dXIVtx6quTx8itc2VrbqnzPmrC3p/ +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDVDCCAjygAwIBAgIDAjRWMA0GCSqGSIb3DQEBBQUAMEIxCzAJBgNVBAYTAlVT +MRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMRswGQYDVQQDExJHZW9UcnVzdCBHbG9i +YWwgQ0EwHhcNMDIwNTIxMDQwMDAwWhcNMjIwNTIxMDQwMDAwWjBCMQswCQYDVQQG +EwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEbMBkGA1UEAxMSR2VvVHJ1c3Qg +R2xvYmFsIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2swYYzD9 +9BcjGlZ+W988bDjkcbd4kdS8odhM+KhDtgPpTSEHCIjaWC9mOSm9BXiLnTjoBbdq +fnGk5sRgprDvgOSJKA+eJdbtg/OtppHHmMlCGDUUna2YRpIuT8rxh0PBFpVXLVDv +iS2Aelet8u5fa9IAjbkU+BQVNdnARqN7csiRv8lVK83Qlz6cJmTM386DGXHKTubU +1XupGc1V3sjs0l44U+VcT4wt/lAjNvxm5suOpDkZALeVAjmRCw7+OC7RHQWa9k0+ +bw8HHa8sHo9gOeL6NlMTOdReJivbPagUvTLrGAMoUgRx5aszPeE4uwc2hGKceeoW +MPRfwCvocWvk+QIDAQABo1MwUTAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTA +ephojYn7qwVkDBF9qn1luMrMTjAfBgNVHSMEGDAWgBTAephojYn7qwVkDBF9qn1l +uMrMTjANBgkqhkiG9w0BAQUFAAOCAQEANeMpauUvXVSOKVCUn5kaFOSPeCpilKIn +Z57QzxpeR+nBsqTP3UEaBU6bS+5Kb1VSsyShNwrrZHYqLizz/Tt1kL/6cdjHPTfS +tQWVYrmm3ok9Nns4d0iXrKYgjy6myQzCsplFAMfOEVEiIuCl6rYVSAlk6l5PdPcF +PseKUgzbFbS9bZvlxrFUaKnjaZC2mqUPuLk/IH2uSrW4nOQdtqvmlKXBx4Ot2/Un +hw4EbNX/3aBd7YdStysVAq45pmp06drE57xNNB6pXE0zX5IJL4hmXXeXxx12E6nV +5fEWCRE11azbJHFwLJhWC9kXtNHjUStedejV0NxPNO3CBWaAocvmMw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDZjCCAk6gAwIBAgIBATANBgkqhkiG9w0BAQUFADBEMQswCQYDVQQGEwJVUzEW +MBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEdMBsGA1UEAxMUR2VvVHJ1c3QgR2xvYmFs +IENBIDIwHhcNMDQwMzA0MDUwMDAwWhcNMTkwMzA0MDUwMDAwWjBEMQswCQYDVQQG +EwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEdMBsGA1UEAxMUR2VvVHJ1c3Qg +R2xvYmFsIENBIDIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDvPE1A +PRDfO1MA4Wf+lGAVPoWI8YkNkMgoI5kF6CsgncbzYEbYwbLVjDHZ3CB5JIG/NTL8 +Y2nbsSpr7iFY8gjpeMtvy/wWUsiRxP89c96xPqfCfWbB9X5SJBri1WeR0IIQ13hL +TytCOb1kLUCgsBDTOEhGiKEMuzozKmKY+wCdE1l/bztyqu6mD4b5BWHqZ38MN5aL +5mkWRxHCJ1kDs6ZgwiFAVvqgx306E+PsV8ez1q6diYD3Aecs9pYrEw15LNnA5IZ7 +S4wMcoKK+xfNAGw6EzywhIdLFnopsk/bHdQL82Y3vdj2V7teJHq4PIu5+pIaGoSe +2HSPqht/XvT+RSIhAgMBAAGjYzBhMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYE +FHE4NvICMVNHK266ZUapEBVYIAUJMB8GA1UdIwQYMBaAFHE4NvICMVNHK266ZUap +EBVYIAUJMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQUFAAOCAQEAA/e1K6td +EPx7srJerJsOflN4WT5CBP51o62sgU7XAotexC3IUnbHLB/8gTKY0UvGkpMzNTEv +/NgdRN3ggX+d6YvhZJFiCzkIjKx0nVnZellSlxG5FntvRdOW2TF9AjYPnDtuzywN +A0ZF66D0f0hExghAzN4bcLUprbqLOzRldRtxIR0sFAqwlpW41uryZfspuk/qkZN0 +abby/+Ea0AzRdoXLiiW9l14sbxWZJue2Kf8i7MkCx1YAzUm5s2x7UwQa4qjJqhIF +I8LO57sEAszAR6LkxCkvW0VXiVHuPOtSCP8HNR6fNWpHSlaY0VqFH4z1Ir+rzoPz +4iIprn2DQKi6bA== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDfDCCAmSgAwIBAgIQGKy1av1pthU6Y2yv2vrEoTANBgkqhkiG9w0BAQUFADBY +MQswCQYDVQQGEwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjExMC8GA1UEAxMo +R2VvVHJ1c3QgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0wNjEx +MjcwMDAwMDBaFw0zNjA3MTYyMzU5NTlaMFgxCzAJBgNVBAYTAlVTMRYwFAYDVQQK +Ew1HZW9UcnVzdCBJbmMuMTEwLwYDVQQDEyhHZW9UcnVzdCBQcmltYXJ5IENlcnRp +ZmljYXRpb24gQXV0aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEAvrgVe//UfH1nrYNke8hCUy3f9oQIIGHWAVlqnEQRr+92/ZV+zmEwu3qDXwK9 +AWbK7hWNb6EwnL2hhZ6UOvNWiAAxz9juapYC2e0DjPt1befquFUWBRaa9OBesYjA +ZIVcFU2Ix7e64HXprQU9nceJSOC7KMgD4TCTZF5SwFlwIjVXiIrxlQqD17wxcwE0 +7e9GceBrAqg1cmuXm2bgyxx5X9gaBGgeRwLmnWDiNpcB3841kt++Z8dtd1k7j53W +kBWUvEI0EME5+bEnPn7WinXFsq+W06Lem+SYvn3h6YGttm/81w7a4DSwDRp35+MI +mO9Y+pyEtzavwt+s0vQQBnBxNQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4G +A1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQULNVQQZcVi/CPNmFbSvtr2ZnJM5IwDQYJ +KoZIhvcNAQEFBQADggEBAFpwfyzdtzRP9YZRqSa+S7iq8XEN3GHHoOo0Hnp3DwQ1 +6CePbJC/kRYkRj5KTs4rFtULUh38H2eiAkUxT87z+gOneZ1TatnaYzr4gNfTmeGl +4b7UVXGYNTq+k+qurUKykG/g/CFNNWMziUnWm07Kx+dOCQD32sfvmWKZd7aVIl6K +oKv0uHiYyjgZmclynnjNS6yvGaBzEi38wkG6gZHaFloxt/m0cYASSJlyc1pZU8Fj +UjPtp8nSOQJw+uCxQmYpqptR7TBUIhRf2asdweSU8Pj1K/fqynhG1riR/aYNKxoU +AT6A8EKglQdebc3MS6RFjasS6LPeWuWgfOgPIh1a6Vk= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICrjCCAjWgAwIBAgIQPLL0SAoA4v7rJDteYD7DazAKBggqhkjOPQQDAzCBmDEL +MAkGA1UEBhMCVVMxFjAUBgNVBAoTDUdlb1RydXN0IEluYy4xOTA3BgNVBAsTMChj +KSAyMDA3IEdlb1RydXN0IEluYy4gLSBGb3IgYXV0aG9yaXplZCB1c2Ugb25seTE2 +MDQGA1UEAxMtR2VvVHJ1c3QgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0 +eSAtIEcyMB4XDTA3MTEwNTAwMDAwMFoXDTM4MDExODIzNTk1OVowgZgxCzAJBgNV +BAYTAlVTMRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMTkwNwYDVQQLEzAoYykgMjAw +NyBHZW9UcnVzdCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxNjA0BgNV +BAMTLUdlb1RydXN0IFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgLSBH +MjB2MBAGByqGSM49AgEGBSuBBAAiA2IABBWx6P0DFUPlrOuHNxFi79KDNlJ9RVcL +So17VDs6bl8VAsBQps8lL33KSLjHUGMcKiEIfJo22Av+0SbFWDEwKCXzXV2juLal +tJLtbCyf691DiaI8S0iRHVDsJt/WYC69IaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFBVfNVdRVfslsq0DafwBo/q+EVXVMAoG +CCqGSM49BAMDA2cAMGQCMGSWWaboCd6LuvpaiIjwH5HTRqjySkwCY/tsXzjbLkGT +qQ7mndwxHLKgpxgceeHHNgIwOlavmnRs9vuD4DPTCF+hnMJbn0bWtsuRBmOiBucz +rD6ogRLQy7rQkgu2npaqBA+K +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIID/jCCAuagAwIBAgIQFaxulBmyeUtB9iepwxgPHzANBgkqhkiG9w0BAQsFADCB +mDELMAkGA1UEBhMCVVMxFjAUBgNVBAoTDUdlb1RydXN0IEluYy4xOTA3BgNVBAsT +MChjKSAyMDA4IEdlb1RydXN0IEluYy4gLSBGb3IgYXV0aG9yaXplZCB1c2Ugb25s +eTE2MDQGA1UEAxMtR2VvVHJ1c3QgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhv +cml0eSAtIEczMB4XDTA4MDQwMjAwMDAwMFoXDTM3MTIwMTIzNTk1OVowgZgxCzAJ +BgNVBAYTAlVTMRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMTkwNwYDVQQLEzAoYykg +MjAwOCBHZW9UcnVzdCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxNjA0 +BgNVBAMTLUdlb1RydXN0IFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkg +LSBHMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANziXmJYHTNXOTIz ++uvLh4yn1ErdBojqZI4xmKU4kB6Yzy5jK/BGvESyiaHAKAxJcCGVn2TAppMSAmUm +hsalifD614SgcK9PGpc/BkTVyetyEH3kMSj7HGHmKAdEc5IiaacDiGydY8hS2pgn +5whMcD60yRLBxWeDXTPzAxHsatBT4tG6NmCUgLthY2xbF37fQJQeqw3CIShwiP/W +JmxsYAQlTlV+fe+/lEjetx3dcI0FX4ilm/LC7urRQEFtYjgdVgbFA0dRIBn8exAL +DmKudlW/X3e+PkkBUz2YJQN2JFodtNuJ6nnltrM7P7pMKEF/BqxqjsHQ9gUdfeZC +huOl1UcCAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYw +HQYDVR0OBBYEFMR5yo6hTgMdHNxr2zFblD4/MH8tMA0GCSqGSIb3DQEBCwUAA4IB +AQAtxRPPVoB7eni9n64smefv2t+UXglpp+duaIy9cr5HqQ6XErhK8WTTOd8lNNTB +zU6B8A8ExCSzNJbGpqow32hhc9f5joWJ7w5elShKKiePEI4ufIbEAp7aDHdlDkQN +kv39sxY2+hENHYwOB4lqKVb3cvTdFZx3NWZXqxNT2I7BQMXXExZacse3aQHEerGD +AWh9jUGhlBjBJVz88P6DAod8DQ3PLghcSkANPuyBYeYk28rgDi0Hsj5W3I31QYUH +SJsMC8tJP33st/3LjWeJGqvtux6jAAgIFyqCXDFdRootD4abdNlF+9RAsXqqaC2G +spki4cErx5z481+oghLrGREt +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFaDCCA1CgAwIBAgIBATANBgkqhkiG9w0BAQUFADBFMQswCQYDVQQGEwJVUzEW +MBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEeMBwGA1UEAxMVR2VvVHJ1c3QgVW5pdmVy +c2FsIENBMB4XDTA0MDMwNDA1MDAwMFoXDTI5MDMwNDA1MDAwMFowRTELMAkGA1UE +BhMCVVMxFjAUBgNVBAoTDUdlb1RydXN0IEluYy4xHjAcBgNVBAMTFUdlb1RydXN0 +IFVuaXZlcnNhbCBDQTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAKYV +VaCjxuAfjJ0hUNfBvitbtaSeodlyWL0AG0y/YckUHUWCq8YdgNY96xCcOq9tJPi8 +cQGeBvV8Xx7BDlXKg5pZMK4ZyzBIle0iN430SppyZj6tlcDgFgDgEB8rMQ7XlFTT +QjOgNB0eRXbdT8oYN+yFFXoZCPzVx5zw8qkuEKmS5j1YPakWaDwvdSEYfyh3peFh +F7em6fgemdtzbvQKoiFs7tqqhZJmr/Z6a4LauiIINQ/PQvE1+mrufislzDoR5G2v +c7J2Ha3QsnhnGqQ5HFELZ1aD/ThdDc7d8Lsrlh/eezJS/R27tQahsiFepdaVaH/w +mZ7cRQg+59IJDTWU3YBOU5fXtQlEIGQWFwMCTFMNaN7VqnJNk22CDtucvc+081xd +VHppCZbW2xHBjXWotM85yM48vCR85mLK4b19p71XZQvk/iXttmkQ3CgaRr0BHdCX +teGYO8A3ZNY9lO4L4fUorgtWv3GLIylBjobFS1J72HGrH4oVpjuDWtdYAVHGTEHZ +f9hBZ3KiKN9gg6meyHv8U3NyWfWTehd2Ds735VzZC1U0oqpbtWpU5xPKV+yXbfRe +Bi9Fi1jUIxaS5BZuKGNZMN9QAZxjiRqf2xeUgnA3wySemkfWWspOqGmJch+RbNt+ +nhutxx9z3SxPGWX9f5NAEC7S8O08ni4oPmkmM8V7AgMBAAGjYzBhMA8GA1UdEwEB +/wQFMAMBAf8wHQYDVR0OBBYEFNq7LqqwDLiIJlF0XG0D08DYj3rWMB8GA1UdIwQY +MBaAFNq7LqqwDLiIJlF0XG0D08DYj3rWMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG +9w0BAQUFAAOCAgEAMXjmx7XfuJRAyXHEqDXsRh3ChfMoWIawC/yOsjmPRFWrZIRc +aanQmjg8+uUfNeVE44B5lGiku8SfPeE0zTBGi1QrlaXv9z+ZhP015s8xxtxqv6fX +IwjhmF7DWgh2qaavdy+3YL1ERmrvl/9zlcGO6JP7/TG37FcREUWbMPEaiDnBTzyn +ANXH/KttgCJwpQzgXQQpAvvLoJHRfNbDflDVnVi+QTjruXU8FdmbyUqDWcDaU/0z +uzYYm4UPFd3uLax2k7nZAY1IEKj79TiG8dsKxr2EoyNB3tZ3b4XUhRxQ4K5RirqN +Pnbiucon8l+f725ZDQbYKxek0nxru18UGkiPGkzns0ccjkxFKyDuSN/n3QmOGKja +QI2SJhFTYXNd673nxE0pN2HrrDktZy4W1vUAg4WhzH92xH3kt0tm7wNFYGm2DFKW +koRepqO1pD4r2czYG0eq8kTaT/kD6PAUyz/zg97QwVTjt+gKN02LIFkDMBmhLMi9 +ER/frslKxfMnZmaGrGiR/9nmUxwPi1xpZQomyB40w11Re9epnAahNt3ViZS82eQt +DF4JbAiXfKM9fJP/P6EUp8+1Xevb2xzEdt+Iub1FBZUbrvxGakyvSOPOrg/Sfuvm +bJxPgWp6ZKy7PtXny3YuxadIwVyQD8vIP/rmMuGNG2+k5o7Y+SlIis5z/iw= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFbDCCA1SgAwIBAgIBATANBgkqhkiG9w0BAQUFADBHMQswCQYDVQQGEwJVUzEW +MBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEgMB4GA1UEAxMXR2VvVHJ1c3QgVW5pdmVy +c2FsIENBIDIwHhcNMDQwMzA0MDUwMDAwWhcNMjkwMzA0MDUwMDAwWjBHMQswCQYD +VQQGEwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEgMB4GA1UEAxMXR2VvVHJ1 +c3QgVW5pdmVyc2FsIENBIDIwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoIC +AQCzVFLByT7y2dyxUxpZKeexw0Uo5dfR7cXFS6GqdHtXr0om/Nj1XqduGdt0DE81 +WzILAePb63p3NeqqWuDW6KFXlPCQo3RWlEQwAx5cTiuFJnSCegx2oG9NzkEtoBUG +FF+3Qs17j1hhNNwqCPkuwwGmIkQcTAeC5lvO0Ep8BNMZcyfwqph/Lq9O64ceJHdq +XbboW0W63MOhBW9Wjo8QJqVJwy7XQYci4E+GymC16qFjwAGXEHm9ADwSbSsVsaxL +se4YuU6W3Nx2/zu+z18DwPw76L5GG//aQMJS9/7jOvdqdzXQ2o3rXhhqMcceujwb +KNZrVMaqW9eiLBsZzKIC9ptZvTdrhrVtgrrY6slWvKk2WP0+GfPtDCapkzj4T8Fd +IgbQl+rhrcZV4IErKIM6+vR7IVEAvlI4zs1meaj0gVbi0IMJR1FbUGrP20gaXT73 +y/Zl92zxlfgCOzJWgjl6W70viRu/obTo/3+NjN8D8WBOWBFM66M/ECuDmgFz2ZRt +hAAnZqzwcEAJQpKtT5MNYQlRJNiS1QuUYbKHsu3/mjX/hVTK7URDrBs8FmtISgoc +QIgfksILAAX/8sgCSqSqqcyZlpwvWOB94b67B9xfBHJcMTTD7F8t4D1kkCLm0ey4 +Lt1ZrtmhN79UNdxzMk+MBB4zsslG8dhcyFVQyWi9qLo2CQIDAQABo2MwYTAPBgNV +HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR281Xh+qQ2+/CfXGJx7Tz0RzgQKzAfBgNV +HSMEGDAWgBR281Xh+qQ2+/CfXGJx7Tz0RzgQKzAOBgNVHQ8BAf8EBAMCAYYwDQYJ +KoZIhvcNAQEFBQADggIBAGbBxiPz2eAubl/oz66wsCVNK/g7WJtAJDday6sWSf+z +dXkzoS9tcBc0kf5nfo/sm+VegqlVHy/c1FEHEv6sFj4sNcZj/NwQ6w2jqtB8zNHQ +L1EuxBRa3ugZ4T7GzKQp5y6EqgYweHZUcyiYWTjgAA1i00J9IZ+uPTqM1fp3DRgr +Fg5fNuH8KrUwJM/gYwx7WBr+mbpCErGR9Hxo4sjoryzqyX6uuyo9DRXcNJW2GHSo +ag/HtPQTxORb7QrSpJdMKu0vbBKJPfEncKpqA1Ihn0CoZ1Dy81of398j9tx4TuaY +T1U6U+Pv8vSfx3zYWK8pIpe44L2RLrB27FcRz+8pRPPphXpgY+RdM4kX2TGq2tbz +GDVyz4crL2MjhF2EjD9XoIj8mZEoJmmZ1I+XRL6O1UixpCgp8RW04eWe3fiPpm8m +1wk8OhwRDqZsN/etRIcsKMfYdIKz0G9KV7s1KSegi+ghp4dkNl3M2Basx7InQJJV +OCiNUW7dFGdTbHFcJoRNdVq2fmBWqU2t+5sel/MN2dKXVHfaPRK34B7vCAas+YWH +6aLcr34YEoP9VhdBLtUpgn2Z9DH2canPLAEnpQW5qrJITirvn5NSUZU8UnOOVkwX +QMAJKOSLakhT2+zNVVXxxvjpoixMptEmX36vWkzaH6byHCx+rgIW0lbQL1dTR+iS +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIB4TCCAYegAwIBAgIRKjikHJYKBN5CsiilC+g0mAIwCgYIKoZIzj0EAwIwUDEk +MCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBDQSAtIFI0MRMwEQYDVQQKEwpH +bG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWduMB4XDTEyMTExMzAwMDAwMFoX +DTM4MDExOTAzMTQwN1owUDEkMCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBD +QSAtIFI0MRMwEQYDVQQKEwpHbG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWdu +MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuMZ5049sJQ6fLjkZHAOkrprlOQcJ +FspjsbmG+IpXwVfOQvpzofdlQv8ewQCybnMO/8ch5RikqtlxP6jUuc6MHaNCMEAw +DgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFFSwe61F +uOJAf/sKbvu+M8k8o4TVMAoGCCqGSM49BAMCA0gAMEUCIQDckqGgE6bPA7DmxCGX +kPoUVy0D7O48027KqGx2vKLeuwIgJ6iFJzWbVsaj8kfSt24bAgAXqmemFZHe+pTs +ewv4n4Q= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICHjCCAaSgAwIBAgIRYFlJ4CYuu1X5CneKcflK2GwwCgYIKoZIzj0EAwMwUDEk +MCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBDQSAtIFI1MRMwEQYDVQQKEwpH +bG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWduMB4XDTEyMTExMzAwMDAwMFoX +DTM4MDExOTAzMTQwN1owUDEkMCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBD +QSAtIFI1MRMwEQYDVQQKEwpHbG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWdu +MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAER0UOlvt9Xb/pOdEh+J8LttV7HpI6SFkc +8GIxLcB6KP4ap1yztsyX50XUWPrRd21DosCHZTQKH3rd6zwzocWdTaRvQZU4f8ke +hOvRnkmSh5SHDDqFSmafnVmTTZdhBoZKo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYD +VR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPeYpSJvqB8ohREom3m7e0oPQn1kwCgYI +KoZIzj0EAwMDaAAwZQIxAOVpEslu28YxuglB4Zf4+/2a4n0Sye18ZNPLBSWLVtmg +515dTguDnFt2KaAJJiFqYgIwcdK1j1zqO+F4CYWodZI7yFz9SO8NdCKoCOJuxUnO +xwy8p2Fp8fc74SrL+SvzZpA3 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDdTCCAl2gAwIBAgILBAAAAAABFUtaw5QwDQYJKoZIhvcNAQEFBQAwVzELMAkG +A1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24gbnYtc2ExEDAOBgNVBAsTB1Jv +b3QgQ0ExGzAZBgNVBAMTEkdsb2JhbFNpZ24gUm9vdCBDQTAeFw05ODA5MDExMjAw +MDBaFw0yODAxMjgxMjAwMDBaMFcxCzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9i +YWxTaWduIG52LXNhMRAwDgYDVQQLEwdSb290IENBMRswGQYDVQQDExJHbG9iYWxT +aWduIFJvb3QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDaDuaZ +jc6j40+Kfvvxi4Mla+pIH/EqsLmVEQS98GPR4mdmzxzdzxtIK+6NiY6arymAZavp +xy0Sy6scTHAHoT0KMM0VjU/43dSMUBUc71DuxC73/OlS8pF94G3VNTCOXkNz8kHp +1Wrjsok6Vjk4bwY8iGlbKk3Fp1S4bInMm/k8yuX9ifUSPJJ4ltbcdG6TRGHRjcdG +snUOhugZitVtbNV4FpWi6cgKOOvyJBNPc1STE4U6G7weNLWLBYy5d4ux2x8gkasJ +U26Qzns3dLlwR5EiUWMWea6xrkEmCMgZK9FGqkjWZCrXgzT/LCrBbBlDSgeF59N8 +9iFo7+ryUp9/k5DPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8E +BTADAQH/MB0GA1UdDgQWBBRge2YaRQ2XyolQL30EzTSo//z9SzANBgkqhkiG9w0B +AQUFAAOCAQEA1nPnfE920I2/7LqivjTFKDK1fPxsnCwrvQmeU79rXqoRSLblCKOz +yj1hTdNGCbM+w6DjY1Ub8rrvrTnhQ7k4o+YviiY776BQVvnGCv04zcQLcFGUl5gE +38NflNUVyRRBnMRddWQVDf9VMOyGj/8N7yy5Y0b2qvzfvGn9LhJIZJrglfCm7ymP +AbEVtQwdpf5pLGkkeB6zpxxxYu7KyJesF12KwvhHhm4qxFYxldBniYUr+WymXUad +DKqC5JlR3XC321Y9YeRq4VzW9v493kHMB65jUr9TU/Qr6cf9tveCX4XSQRjbgbME +HMUfpIBvFSDJ3gyICh3WZlXi/EjJKSZp4A== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDujCCAqKgAwIBAgILBAAAAAABD4Ym5g0wDQYJKoZIhvcNAQEFBQAwTDEgMB4G +A1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjIxEzARBgNVBAoTCkdsb2JhbFNp +Z24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMDYxMjE1MDgwMDAwWhcNMjExMjE1 +MDgwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSMjETMBEG +A1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCASIwDQYJKoZI +hvcNAQEBBQADggEPADCCAQoCggEBAKbPJA6+Lm8omUVCxKs+IVSbC9N/hHD6ErPL +v4dfxn+G07IwXNb9rfF73OX4YJYJkhD10FPe+3t+c4isUoh7SqbKSaZeqKeMWhG8 +eoLrvozps6yWJQeXSpkqBy+0Hne/ig+1AnwblrjFuTosvNYSuetZfeLQBoZfXklq +tTleiDTsvHgMCJiEbKjNS7SgfQx5TfC4LcshytVsW33hoCmEofnTlEnLJGKRILzd +C9XZzPnqJworc5HGnRusyMvo4KD0L5CLTfuwNhv2GXqF4G3yYROIXJ/gkwpRl4pa +zq+r1feqCapgvdzZX99yqWATXgAByUr6P6TqBwMhAo6CygPCm48CAwEAAaOBnDCB +mTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm+IH +V2ccHsBqBt5ZtJot39wZhi4wNgYDVR0fBC8wLTAroCmgJ4YlaHR0cDovL2NybC5n +bG9iYWxzaWduLm5ldC9yb290LXIyLmNybDAfBgNVHSMEGDAWgBSb4gdXZxwewGoG +3lm0mi3f3BmGLjANBgkqhkiG9w0BAQUFAAOCAQEAmYFThxxol4aR7OBKuEQLq4Gs +J0/WwbgcQ3izDJr86iw8bmEbTUsp9Z8FHSbBuOmDAGJFtqkIk7mpM0sYmsL4h4hO +291xNBrBVNpGP+DTKqttVCL1OmLNIG+6KYnX3ZHu01yiPqFbQfXf5WRDLenVOavS +ot+3i9DAgBkcRcAtjOj4LaR0VknFBbVPFd5uRHg5h6h+u/N5GJG79G+dwfCMNYxd +AfvDbbnvRG15RjF+Cv6pgsH/76tuIMRQyV+dTZsXjAzlAcmgQWpzU/qlULRuJQ/7 +TBj0/VLZjmmx6BEP3ojY+x1J96relc8geMJgEtslQIxq/H5COEBkEveegeGTLg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDXzCCAkegAwIBAgILBAAAAAABIVhTCKIwDQYJKoZIhvcNAQELBQAwTDEgMB4G +A1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjMxEzARBgNVBAoTCkdsb2JhbFNp +Z24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMDkwMzE4MTAwMDAwWhcNMjkwMzE4 +MTAwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSMzETMBEG +A1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCASIwDQYJKoZI +hvcNAQEBBQADggEPADCCAQoCggEBAMwldpB5BngiFvXAg7aEyiie/QV2EcWtiHL8 +RgJDx7KKnQRfJMsuS+FggkbhUqsMgUdwbN1k0ev1LKMPgj0MK66X17YUhhB5uzsT +gHeMCOFJ0mpiLx9e+pZo34knlTifBtc+ycsmWQ1z3rDI6SYOgxXG71uL0gRgykmm +KPZpO/bLyCiR5Z2KYVc3rHQU3HTgOu5yLy6c+9C7v/U9AOEGM+iCK65TpjoWc4zd +QQ4gOsC0p6Hpsk+QLjJg6VfLuQSSaGjlOCZgdbKfd/+RFO+uIEn8rUAVSNECMWEZ +XriX7613t2Saer9fwRPvm2L7DWzgVGkWqQPabumDk3F2xmmFghcCAwEAAaNCMEAw +DgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFI/wS3+o +LkUkrk1Q+mOai97i3Ru8MA0GCSqGSIb3DQEBCwUAA4IBAQBLQNvAUKr+yAzv95ZU +RUm7lgAJQayzE4aGKAczymvmdLm6AC2upArT9fHxD4q/c2dKg8dEe3jgr25sbwMp +jjM5RcOO5LlXbKr8EpbsU8Yt5CRsuZRj+9xTaGdWPoO4zzUhw8lo/s7awlOqzJCK +6fBdRoyV3XpYKBovHd7NADdBj+1EbddTKJd+82cEHhXXipa0095MJ6RMG3NzdvQX +mcIfeg7jLQitChws/zyrVQ4PkX4268NXSb7hLi18YIvDQVETI53O9zJrlAGomecs +Mx86OyXShkDOOyyGeMlhLxS67ttVb9+E7gUJTb0o2HLO02JQZR7rkpeDMdmztcpH +WD9f +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIHSTCCBTGgAwIBAgIJAMnN0+nVfSPOMA0GCSqGSIb3DQEBBQUAMIGsMQswCQYD +VQQGEwJFVTFDMEEGA1UEBxM6TWFkcmlkIChzZWUgY3VycmVudCBhZGRyZXNzIGF0 +IHd3dy5jYW1lcmZpcm1hLmNvbS9hZGRyZXNzKTESMBAGA1UEBRMJQTgyNzQzMjg3 +MRswGQYDVQQKExJBQyBDYW1lcmZpcm1hIFMuQS4xJzAlBgNVBAMTHkdsb2JhbCBD +aGFtYmVyc2lnbiBSb290IC0gMjAwODAeFw0wODA4MDExMjMxNDBaFw0zODA3MzEx +MjMxNDBaMIGsMQswCQYDVQQGEwJFVTFDMEEGA1UEBxM6TWFkcmlkIChzZWUgY3Vy +cmVudCBhZGRyZXNzIGF0IHd3dy5jYW1lcmZpcm1hLmNvbS9hZGRyZXNzKTESMBAG +A1UEBRMJQTgyNzQzMjg3MRswGQYDVQQKExJBQyBDYW1lcmZpcm1hIFMuQS4xJzAl +BgNVBAMTHkdsb2JhbCBDaGFtYmVyc2lnbiBSb290IC0gMjAwODCCAiIwDQYJKoZI +hvcNAQEBBQADggIPADCCAgoCggIBAMDfVtPkOpt2RbQT2//BthmLN0EYlVJH6xed +KYiONWwGMi5HYvNJBL99RDaxccy9Wglz1dmFRP+RVyXfXjaOcNFccUMd2drvXNL7 +G706tcuto8xEpw2uIRU/uXpbknXYpBI4iRmKt4DS4jJvVpyR1ogQC7N0ZJJ0YPP2 +zxhPYLIj0Mc7zmFLmY/CDNBAspjcDahOo7kKrmCgrUVSY7pmvWjg+b4aqIG7HkF4 +ddPB/gBVsIdU6CeQNR1MM62X/JcumIS/LMmjv9GYERTtY/jKmIhYF5ntRQOXfjyG +HoiMvvKRhI9lNNgATH23MRdaKXoKGCQwoze1eqkBfSbW+Q6OWfH9GzO1KTsXO0G2 +Id3UwD2ln58fQ1DJu7xsepeY7s2MH/ucUa6LcL0nn3HAa6x9kGbo1106DbDVwo3V +yJ2dwW3Q0L9R5OP4wzg2rtandeavhENdk5IMagfeOx2YItaswTXbo6Al/3K1dh3e +beksZixShNBFks4c5eUzHdwHU1SjqoI7mjcv3N2gZOnm3b2u/GSFHTynyQbehP9r +6GsaPMWis0L7iwk+XwhSx2LE1AVxv8Rk5Pihg+g+EpuoHtQ2TS9x9o0o9oOpE9Jh +wZG7SMA0j0GMS0zbaRL/UJScIINZc+18ofLx/d33SdNDWKBWY8o9PeU1VlnpDsog +zCtLkykPAgMBAAGjggFqMIIBZjASBgNVHRMBAf8ECDAGAQH/AgEMMB0GA1UdDgQW +BBS5CcqcHtvTbDprru1U8VuTBjUuXjCB4QYDVR0jBIHZMIHWgBS5CcqcHtvTbDpr +ru1U8VuTBjUuXqGBsqSBrzCBrDELMAkGA1UEBhMCRVUxQzBBBgNVBAcTOk1hZHJp +ZCAoc2VlIGN1cnJlbnQgYWRkcmVzcyBhdCB3d3cuY2FtZXJmaXJtYS5jb20vYWRk +cmVzcykxEjAQBgNVBAUTCUE4Mjc0MzI4NzEbMBkGA1UEChMSQUMgQ2FtZXJmaXJt +YSBTLkEuMScwJQYDVQQDEx5HbG9iYWwgQ2hhbWJlcnNpZ24gUm9vdCAtIDIwMDiC +CQDJzdPp1X0jzjAOBgNVHQ8BAf8EBAMCAQYwPQYDVR0gBDYwNDAyBgRVHSAAMCow +KAYIKwYBBQUHAgEWHGh0dHA6Ly9wb2xpY3kuY2FtZXJmaXJtYS5jb20wDQYJKoZI +hvcNAQEFBQADggIBAICIf3DekijZBZRG/5BXqfEv3xoNa/p8DhxJJHkn2EaqbylZ +UohwEurdPfWbU1Rv4WCiqAm57OtZfMY18dwY6fFn5a+6ReAJ3spED8IXDneRRXoz +X1+WLGiLwUePmJs9wOzL9dWCkoQ10b42OFZyMVtHLaoXpGNR6woBrX/sdZ7LoR/x +fxKxueRkf2fWIyr0uDldmOghp+G9PUIadJpwr2hsUF1Jz//7Dl3mLEfXgTpZALVz +a2Mg9jFFCDkO9HB+QHBaP9BrQql0PSgvAm11cpUJjUhjxsYjV5KTXjXBjfkK9yyd +Yhz2rXzdpjEetrHHfoUm+qRqtdpjMNHvkzeyZi99Bffnt0uYlDXA2TopwZ2yUDMd +SqlapskD7+3056huirRXhOukP9DuqqqHW2Pok+JrqNS4cnhrG+055F3Lm6qH1U9O +AP7Zap88MQ8oAgF9mOinsKJknnn4SPIVqczmyETrP3iZ8ntxPjzxmKfFGBI/5rso +M0LpRQp8bfKGeS/Fghl9CYl8slR2iK7ewfPM4W7bMdaTrpmg7yVqc5iJWzouE4ge +v8CSlDQb4ye3ix5vQv/n6TebUB0tovkC7stYWDpxvGjjqsGvHCgfotwjZT+B6q6Z +09gwzxMNTxXJhLynSC34MCN32EZLeW32jO06f2ARePTpm67VVMB0gNELQp/B +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEADCCAuigAwIBAgIBADANBgkqhkiG9w0BAQUFADBjMQswCQYDVQQGEwJVUzEh +MB8GA1UEChMYVGhlIEdvIERhZGR5IEdyb3VwLCBJbmMuMTEwLwYDVQQLEyhHbyBE +YWRkeSBDbGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA0MDYyOTE3 +MDYyMFoXDTM0MDYyOTE3MDYyMFowYzELMAkGA1UEBhMCVVMxITAfBgNVBAoTGFRo +ZSBHbyBEYWRkeSBHcm91cCwgSW5jLjExMC8GA1UECxMoR28gRGFkZHkgQ2xhc3Mg +MiBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCCASAwDQYJKoZIhvcNAQEBBQADggEN +ADCCAQgCggEBAN6d1+pXGEmhW+vXX0iG6r7d/+TvZxz0ZWizV3GgXne77ZtJ6XCA +PVYYYwhv2vLM0D9/AlQiVBDYsoHUwHU9S3/Hd8M+eKsaA7Ugay9qK7HFiH7Eux6w +wdhFJ2+qN1j3hybX2C32qRe3H3I2TqYXP2WYktsqbl2i/ojgC95/5Y0V4evLOtXi +EqITLdiOr18SPaAIBQi2XKVlOARFmR6jYGB0xUGlcmIbYsUfb18aQr4CUWWoriMY +avx4A6lNf4DD+qta/KFApMoZFv6yyO9ecw3ud72a9nmYvLEHZ6IVDd2gWMZEewo+ +YihfukEHU1jPEX44dMX4/7VpkI+EdOqXG68CAQOjgcAwgb0wHQYDVR0OBBYEFNLE +sNKR1EwRcbNhyz2h/t2oatTjMIGNBgNVHSMEgYUwgYKAFNLEsNKR1EwRcbNhyz2h +/t2oatTjoWekZTBjMQswCQYDVQQGEwJVUzEhMB8GA1UEChMYVGhlIEdvIERhZGR5 +IEdyb3VwLCBJbmMuMTEwLwYDVQQLEyhHbyBEYWRkeSBDbGFzcyAyIENlcnRpZmlj +YXRpb24gQXV0aG9yaXR5ggEAMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQAD +ggEBADJL87LKPpH8EsahB4yOd6AzBhRckB4Y9wimPQoZ+YeAEW5p5JYXMP80kWNy +OO7MHAGjHZQopDH2esRU1/blMVgDoszOYtuURXO1v0XJJLXVggKtI3lpjbi2Tc7P +TMozI+gciKqdi0FuFskg5YmezTvacPd+mSYgFFQlq25zheabIZ0KbIIOqPjCDPoQ +HmyW74cNxA9hi63ugyuV+I6ShHI56yDqg+2DzZduCLzrTia2cyvk0/ZM/iZx4mER +dEr/VxqHD3VILs9RaRegAhJhldXRQLIQTO7ErBBDpqWeCtWVYpoNz4iCxTIM5Cuf +ReYNnyicsbkqWletNw+vHX/bvZ8= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDxTCCAq2gAwIBAgIBADANBgkqhkiG9w0BAQsFADCBgzELMAkGA1UEBhMCVVMx +EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxGjAYBgNVBAoT +EUdvRGFkZHkuY29tLCBJbmMuMTEwLwYDVQQDEyhHbyBEYWRkeSBSb290IENlcnRp +ZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5MDkwMTAwMDAwMFoXDTM3MTIzMTIz +NTk1OVowgYMxCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdBcml6b25hMRMwEQYDVQQH +EwpTY290dHNkYWxlMRowGAYDVQQKExFHb0RhZGR5LmNvbSwgSW5jLjExMC8GA1UE +AxMoR28gRGFkZHkgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgLSBHMjCCASIw +DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAL9xYgjx+lk09xvJGKP3gElY6SKD +E6bFIEMBO4Tx5oVJnyfq9oQbTqC023CYxzIBsQU+B07u9PpPL1kwIuerGVZr4oAH +/PMWdYA5UXvl+TW2dE6pjYIT5LY/qQOD+qK+ihVqf94Lw7YZFAXK6sOoBJQ7Rnwy +DfMAZiLIjWltNowRGLfTshxgtDj6AozO091GB94KPutdfMh8+7ArU6SSYmlRJQVh +GkSBjCypQ5Yj36w6gZoOKcUcqeldHraenjAKOc7xiID7S13MMuyFYkMlNAJWJwGR +tDtwKj9useiciAF9n9T521NtYJ2/LOdYq7hfRvzOxBsDPAnrSTFcaUaz4EcCAwEA +AaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYE +FDqahQcQZyi27/a9BUFuIMGU2g/eMA0GCSqGSIb3DQEBCwUAA4IBAQCZ21151fmX +WWcDYfF+OwYxdS2hII5PZYe096acvNjpL9DbWu7PdIxztDhC2gV7+AJ1uP2lsdeu +9tfeE8tTEH6KRtGX+rcuKxGrkLAngPnon1rpN5+r5N9ss4UXnT3ZJE95kTXWXwTr +gIOrmgIttRD02JDHBHNA7XIloKmf7J6raBKZV8aPEjoJpL1E/QYVN8Gb5DKj7Tjo +2GTzLH4U/ALqn83/B2gX2yKQOC16jdFU8WnjXzPKej17CuPKf1855eJ1usV2GDPO +LPAvTK33sefOT6jEm0pUBsV/fdUID+Ic/n4XuKxe9tQWskMJDE32p2u0mYRlynqI +4uJEvlz36hz1 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEMTCCAxmgAwIBAgIBADANBgkqhkiG9w0BAQUFADCBlTELMAkGA1UEBhMCR1Ix +RDBCBgNVBAoTO0hlbGxlbmljIEFjYWRlbWljIGFuZCBSZXNlYXJjaCBJbnN0aXR1 +dGlvbnMgQ2VydC4gQXV0aG9yaXR5MUAwPgYDVQQDEzdIZWxsZW5pYyBBY2FkZW1p +YyBhbmQgUmVzZWFyY2ggSW5zdGl0dXRpb25zIFJvb3RDQSAyMDExMB4XDTExMTIw +NjEzNDk1MloXDTMxMTIwMTEzNDk1MlowgZUxCzAJBgNVBAYTAkdSMUQwQgYDVQQK +EztIZWxsZW5pYyBBY2FkZW1pYyBhbmQgUmVzZWFyY2ggSW5zdGl0dXRpb25zIENl +cnQuIEF1dGhvcml0eTFAMD4GA1UEAxM3SGVsbGVuaWMgQWNhZGVtaWMgYW5kIFJl +c2VhcmNoIEluc3RpdHV0aW9ucyBSb290Q0EgMjAxMTCCASIwDQYJKoZIhvcNAQEB +BQADggEPADCCAQoCggEBAKlTAOMupvaO+mDYLZU++CwqVE7NuYRhlFhPjz2L5EPz +dYmNUeTDN9KKiE15HrcS3UN4SoqS5tdI1Q+kOilENbgH9mgdVc04UfCMJDGFr4PJ +fel3r+0ae50X+bOdOFAPplp5kYCvN66m0zH7tSYJnTxa71HFK9+WXesyHgLacEns +bgzImjeN9/E2YEsmLIKe0HjzDQ9jpFEw4fkrJxIH2Oq9GGKYsFk3fb7u8yBRQlqD +75O6aRXxYp2fmTmCobd0LovUxQt7L/DICto9eQqakxylKHJzkUOap9FNhYS5qXSP +FEDH3N6sQWRstBmbAmNtJGSPRLIl6s5ddAxjMlyNh+UCAwEAAaOBiTCBhjAPBgNV +HRMBAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAdBgNVHQ4EFgQUppFC/RNhSiOeCKQp +5dgTBCPuQSUwRwYDVR0eBEAwPqA8MAWCAy5ncjAFggMuZXUwBoIELmVkdTAGggQu +b3JnMAWBAy5ncjAFgQMuZXUwBoEELmVkdTAGgQQub3JnMA0GCSqGSIb3DQEBBQUA +A4IBAQAf73lB4XtuP7KMhjdCSk4cNx6NZrokgclPEg8hwAOXhiVtXdMiKahsog2p +6z0GW5k6x8zDmjR/qw7IThzh+uTczQ2+vyT+bOdrwg3IBp5OjWEopmr95fZi6hg8 +TqBTnbI6nOulnJEWtk2C4AwFSKls9cz4y51JtPACpf1wA+2KIaWuE4ZJwzNzvoc7 +dIsXRSZMFpGD/md9zU1jZ/rzAxKWeAaNsWftjj++n08C9bMJL/NMh98qy5V8Acys +Nnq/onN694/BtZqhFLKPM58N7yLcZnuEvUUXBj08yrl3NI/K6s8/MT7jiOOASSXI +l7WdmplNsDz4SgCbZN2fOUvRJ9e4 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDMDCCAhigAwIBAgICA+gwDQYJKoZIhvcNAQEFBQAwRzELMAkGA1UEBhMCSEsx +FjAUBgNVBAoTDUhvbmdrb25nIFBvc3QxIDAeBgNVBAMTF0hvbmdrb25nIFBvc3Qg +Um9vdCBDQSAxMB4XDTAzMDUxNTA1MTMxNFoXDTIzMDUxNTA0NTIyOVowRzELMAkG +A1UEBhMCSEsxFjAUBgNVBAoTDUhvbmdrb25nIFBvc3QxIDAeBgNVBAMTF0hvbmdr +b25nIFBvc3QgUm9vdCBDQSAxMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEArP84tulmAknjorThkPlAj3n54r15/gK97iSSHSL22oVyaf7XPwnU3ZG1ApzQ +jVrhVcNQhrkpJsLj2aDxaQMoIIBFIi1WpztUlVYiWR8o3x8gPW2iNr4joLFutbEn +PzlTCeqrauh0ssJlXI6/fMN4hM2eFvz1Lk8gKgifd/PFHsSaUmYeSF7jEAaPIpjh +ZY4bXSNmO7ilMlHIhqqhqZ5/dpTCpmy3QfDVyAY45tQM4vM7TG1QjMSDJ8EThFk9 +nnV0ttgCXjqQesBCNnLsak3c78QA3xMYV18meMjWCnl3v/evt3a5pQuEF10Q6m/h +q5URX208o1xNg1vysxmKgIsLhwIDAQABoyYwJDASBgNVHRMBAf8ECDAGAQH/AgED +MA4GA1UdDwEB/wQEAwIBxjANBgkqhkiG9w0BAQUFAAOCAQEADkbVPK7ih9legYsC +mEEIjEy82tvuJxuC52pF7BaLT4Wg87JwvVqWuspube5Gi27nKi6Wsxkz67SfqLI3 +7piol7Yutmcn1KZJ/RyTZXaeQi/cImyaT/JaFTmxcdcrUehtHJjA2Sr0oYJ71clB +oiMBdDhViw+5LmeiIAQ32pwL0xch4I+XeTRvhEgCIDMb5jREn5Fw9IBehEPCKdJs +EhTkYY2sEJCehFC78JZvRZ+K88psT/oROhUVRsPNH4NbLUES7VBnQRM9IauUiqpO +fMGx+6fWtScvl6tu4B3i0RwsH0Ti/L6RoZz71ilTc4afU9hDDl3WY4JxHYB0yvbi +AmvZWg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEAjCCAuqgAwIBAgIFORFFEJQwDQYJKoZIhvcNAQEFBQAwgYUxCzAJBgNVBAYT +AkZSMQ8wDQYDVQQIEwZGcmFuY2UxDjAMBgNVBAcTBVBhcmlzMRAwDgYDVQQKEwdQ +TS9TR0ROMQ4wDAYDVQQLEwVEQ1NTSTEOMAwGA1UEAxMFSUdDL0ExIzAhBgkqhkiG +9w0BCQEWFGlnY2FAc2dkbi5wbS5nb3V2LmZyMB4XDTAyMTIxMzE0MjkyM1oXDTIw +MTAxNzE0MjkyMlowgYUxCzAJBgNVBAYTAkZSMQ8wDQYDVQQIEwZGcmFuY2UxDjAM +BgNVBAcTBVBhcmlzMRAwDgYDVQQKEwdQTS9TR0ROMQ4wDAYDVQQLEwVEQ1NTSTEO +MAwGA1UEAxMFSUdDL0ExIzAhBgkqhkiG9w0BCQEWFGlnY2FAc2dkbi5wbS5nb3V2 +LmZyMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsh/R0GLFMzvABIaI +s9z4iPf930Pfeo2aSVz2TqrMHLmh6yeJ8kbpO0px1R2OLc/mratjUMdUC24SyZA2 +xtgv2pGqaMVy/hcKshd+ebUyiHDKcMCWSo7kVc0dJ5S/znIq7Fz5cyD+vfcuiWe4 +u0dzEvfRNWk68gq5rv9GQkaiv6GFGvm/5P9JhfejcIYyHF2fYPepraX/z9E0+X1b +F8bc1g4oa8Ld8fUzaJ1O/Id8NhLWo4DoQw1VYZTqZDdH6nfK0LJYBcNdfrGoRpAx +Vs5wKpayMLh35nnAvSk7/ZR3TL0gzUEl4C7HG7vupARB0l2tEmqKm0f7yd1GQOGd +PDPQtQIDAQABo3cwdTAPBgNVHRMBAf8EBTADAQH/MAsGA1UdDwQEAwIBRjAVBgNV +HSAEDjAMMAoGCCqBegF5AQEBMB0GA1UdDgQWBBSjBS8YYFDCiQrdKyFP/45OqDAx +NjAfBgNVHSMEGDAWgBSjBS8YYFDCiQrdKyFP/45OqDAxNjANBgkqhkiG9w0BAQUF +AAOCAQEABdwm2Pp3FURo/C9mOnTgXeQp/wYHE4RKq89toB9RlPhJy3Q2FLwV3duJ +L92PoF189RLrn544pEfMs5bZvpwlqwN+Mw+VgQ39FuCIvjfwbF3QMZsyK10XZZOY +YLxuj7GoPB7ZHPOpJkL5ZB3C55L29B5aqhlSXa/oovdgoPaN8In1buAKBQGVyYsg +Crpa/JosPL3Dt8ldeCUFP1YUmwza+zpI/pdpXsoQhvdOlgQITeywvl3cO45Pwf2a +NjSaTFR+FwNIlQgRHAdvhQh+XU3Endv7rs6y0bO4g2wdsrN58dhwmX7wEwLOXt1R +0982gaEbeC9xs/FZTEYYKKuF0mBWWg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFYDCCA0igAwIBAgIQCgFCgAAAAUUjyES1AAAAAjANBgkqhkiG9w0BAQsFADBK +MQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0MScwJQYDVQQDEx5JZGVu +VHJ1c3QgQ29tbWVyY2lhbCBSb290IENBIDEwHhcNMTQwMTE2MTgxMjIzWhcNMzQw +MTE2MTgxMjIzWjBKMQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0MScw +JQYDVQQDEx5JZGVuVHJ1c3QgQ29tbWVyY2lhbCBSb290IENBIDEwggIiMA0GCSqG +SIb3DQEBAQUAA4ICDwAwggIKAoICAQCnUBneP5k91DNG8W9RYYKyqU+PZ4ldhNlT +3Qwo2dfw/66VQ3KZ+bVdfIrBQuExUHTRgQ18zZshq0PirK1ehm7zCYofWjK9ouuU ++ehcCuz/mNKvcbO0U59Oh++SvL3sTzIwiEsXXlfEU8L2ApeN2WIrvyQfYo3fw7gp +S0l4PJNgiCL8mdo2yMKi1CxUAGc1bnO/AljwpN3lsKImesrgNqUZFvX9t++uP0D1 +bVoE/c40yiTcdCMbXTMTEl3EASX2MN0CXZ/g1Ue9tOsbobtJSdifWwLziuQkkORi +T0/Br4sOdBeo0XKIanoBScy0RnnGF7HamB4HWfp1IYVl3ZBWzvurpWCdxJ35UrCL +vYf5jysjCiN2O/cz4ckA82n5S6LgTrx+kzmEB/dEcH7+B1rlsazRGMzyNeVJSQjK +Vsk9+w8YfYs7wRPCTY/JTw436R+hDmrfYi7LNQZReSzIJTj0+kuniVyc0uMNOYZK +dHzVWYfCP04MXFL0PfdSgvHqo6z9STQaKPNBiDoT7uje/5kdX7rL6B7yuVBgwDHT +c+XvvqDtMwt0viAgxGds8AgDelWAf0ZOlqf0Hj7h9tgJ4TNkK2PXMl6f+cB7D3hv +l7yTmvmcEpB4eoCHFddydJxVdHixuuFucAS6T6C6aMN7/zHwcz09lCqxC0EOoP5N +iGVreTO01wIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB +/zAdBgNVHQ4EFgQU7UQZwNPwBovupHu+QucmVMiONnYwDQYJKoZIhvcNAQELBQAD +ggIBAA2ukDL2pkt8RHYZYR4nKM1eVO8lvOMIkPkp165oCOGUAFjvLi5+U1KMtlwH +6oi6mYtQlNeCgN9hCQCTrQ0U5s7B8jeUeLBfnLOic7iPBZM4zY0+sLj7wM+x8uwt +LRvM7Kqas6pgghstO8OEPVeKlh6cdbjTMM1gCIOQ045U8U1mwF10A0Cj7oV+wh93 +nAbowacYXVKV7cndJZ5t+qntozo00Fl72u1Q8zW/7esUTTHHYPTa8Yec4kjixsU3 ++wYQ+nVZZjFHKdp2mhzpgq7vmrlR94gjmmmVYjzlVYA211QC//G5Xc7UI2/YRYRK +W2XviQzdFKcgyxilJbQN+QHwotL0AMh0jqEqSI5l2xPE4iUXfeu+h1sXIFRRk0pT +AwvsXcoz7WL9RccvW9xYoIA55vrX/hMUpu09lEpCdNTDd1lzzY9GvlU47/rokTLq +l1gEIt44w8y8bckzOmoKaT+gyOpyj4xjhiO9bTyWnpXgSUyqorkqG5w2gXjtw+hG +4iZZRHUe2XWJUc0QhJ1hYMtd+ZciTY6Y5uN/9lu7rs3KSoFrXgvzUeF0K+l+J6fZ +mUlO+KWA2yUPHGNiiskzZ2s8EIPGrd6ozRaOjfAHN3Gf8qv8QfXBi+wAN10J5U6A +7/qxXDgGpRtK4dw4LTzcqx+QGtVKnO7RcGzM7vRX+Bi6hG6H +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFZjCCA06gAwIBAgIQCgFCgAAAAUUjz0Z8AAAAAjANBgkqhkiG9w0BAQsFADBN +MQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0MSowKAYDVQQDEyFJZGVu +VHJ1c3QgUHVibGljIFNlY3RvciBSb290IENBIDEwHhcNMTQwMTE2MTc1MzMyWhcN +MzQwMTE2MTc1MzMyWjBNMQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0 +MSowKAYDVQQDEyFJZGVuVHJ1c3QgUHVibGljIFNlY3RvciBSb290IENBIDEwggIi +MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC2IpT8pEiv6EdrCvsnduTyP4o7 +ekosMSqMjbCpwzFrqHd2hCa2rIFCDQjrVVi7evi8ZX3yoG2LqEfpYnYeEe4IFNGy +RBb06tD6Hi9e28tzQa68ALBKK0CyrOE7S8ItneShm+waOh7wCLPQ5CQ1B5+ctMlS +bdsHyo+1W/CD80/HLaXIrcuVIKQxKFdYWuSNG5qrng0M8gozOSI5Cpcu81N3uURF +/YTLNiCBWS2ab21ISGHKTN9T0a9SvESfqy9rg3LvdYDaBjMbXcjaY8ZNzaxmMc3R +3j6HEDbhuaR672BQssvKplbgN6+rNBM5Jeg5ZuSYeqoSmJxZZoY+rfGwyj4GD3vw +EUs3oERte8uojHH01bWRNszwFcYr3lEXsZdMUD2xlVl8BX0tIdUAvwFnol57plzy +9yLxkA2T26pEUWbMfXYD62qoKjgZl3YNa4ph+bz27nb9cCvdKTz4Ch5bQhyLVi9V +GxyhLrXHFub4qjySjmm2AcG1hp2JDws4lFTo6tyePSW8Uybt1as5qsVATFSrsrTZ +2fjXctscvG29ZV/viDUqZi/u9rNl8DONfJhBaUYPQxxp+pu10GFqzcpL2UyQRqsV +WaFHVCkugyhfHMKiq3IXAAaOReyL4jM9f9oZRORicsPfIsbyVtTdX5Vy7W1f90gD +W/3FKqD2cyOEEBsB5wIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/ +BAUwAwEB/zAdBgNVHQ4EFgQU43HgntinQtnbcZFrlJPrw6PRFKMwDQYJKoZIhvcN +AQELBQADggIBAEf63QqwEZE4rU1d9+UOl1QZgkiHVIyqZJnYWv6IAcVYpZmxI1Qj +t2odIFflAWJBF9MJ23XLblSQdf4an4EKwt3X9wnQW3IV5B4Jaj0z8yGa5hV+rVHV +DRDtfULAj+7AmgjVQdZcDiFpboBhDhXAuM/FSRJSzL46zNQuOAXeNf0fb7iAaJg9 +TaDKQGXSc3z1i9kKlT/YPyNtGtEqJBnZhbMX73huqVjRI9PHE+1yJX9dsXNw0H8G +lwmEKYBhHfpe/3OsoOOJuBxxFcbeMX8S3OFtm6/n6J91eEyrRjuazr8FGF1NFTwW +mhlQBJqymm9li1JfPFgEKCXAZmExfrngdbkaqIHWchezxQMxNRF4eKLg6TCMf4Df +WN88uieW4oA0beOY02QnrEh+KHdcxiVhJfiFDGX6xDIvpZgF5PgLZxYWxoK4Mhn5 ++bl53B/N66+rDt0b20XkeucC4pVd/GnwU2lhlXV5C15V5jgclKlZM57IcXR5f1GJ +tshquDDIajjDbp7hNxbqBWJMWxJH7ae0s1hWx0nzfxJoCTFx8G34Tkf71oXuxVhA +GaQdp/lLQzfcaFpPz+vCZHTetBXZ9FRUGi8c15dxVJCO2SCdUyt/q4/i6jC8UDfv +8Ue1fXwsBOxonbRJRBD0ckscZOf85muQ3Wl9af0AVqW3rLatt8o+Ae+c +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIF8TCCA9mgAwIBAgIQALC3WhZIX7/hy/WL1xnmfTANBgkqhkiG9w0BAQsFADA4 +MQswCQYDVQQGEwJFUzEUMBIGA1UECgwLSVpFTlBFIFMuQS4xEzARBgNVBAMMCkl6 +ZW5wZS5jb20wHhcNMDcxMjEzMTMwODI4WhcNMzcxMjEzMDgyNzI1WjA4MQswCQYD +VQQGEwJFUzEUMBIGA1UECgwLSVpFTlBFIFMuQS4xEzARBgNVBAMMCkl6ZW5wZS5j +b20wggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDJ03rKDx6sp4boFmVq +scIbRTJxldn+EFvMr+eleQGPicPK8lVx93e+d5TzcqQsRNiekpsUOqHnJJAKClaO +xdgmlOHZSOEtPtoKct2jmRXagaKH9HtuJneJWK3W6wyyQXpzbm3benhB6QiIEn6H +LmYRY2xU+zydcsC8Lv/Ct90NduM61/e0aL6i9eOBbsFGb12N4E3GVFWJGjMxCrFX +uaOKmMPsOzTFlUFpfnXCPCDFYbpRR6AgkJOhkEvzTnyFRVSa0QUmQbC1TR0zvsQD +yCV8wXDbO/QJLVQnSKwv4cSsPsjLkkxTOTcj7NMB+eAJRE1NZMDhDVqHIrytG6P+ +JrUV86f8hBnp7KGItERphIPzidF0BqnMC9bC3ieFUCbKF7jJeodWLBoBHmy+E60Q +rLUk9TiRodZL2vG70t5HtfG8gfZZa88ZU+mNFctKy6lvROUbQc/hhqfK0GqfvEyN +BjNaooXlkDWgYlwWTvDjovoDGrQscbNYLN57C9saD+veIR8GdwYDsMnvmfzAuU8L +hij+0rnq49qlw0dpEuDb8PYZi+17cNcC1u2HGCgsBCRMd+RIihrGO5rUD8r6ddIB +QFqNeb+Lz0vPqhbBleStTIo+F5HUsWLlguWABKQDfo2/2n+iD5dPDNMN+9fR5XJ+ +HMh3/1uaD7euBUbl8agW7EekFwIDAQABo4H2MIHzMIGwBgNVHREEgagwgaWBD2lu +Zm9AaXplbnBlLmNvbaSBkTCBjjFHMEUGA1UECgw+SVpFTlBFIFMuQS4gLSBDSUYg +QTAxMzM3MjYwLVJNZXJjLlZpdG9yaWEtR2FzdGVpeiBUMTA1NSBGNjIgUzgxQzBB +BgNVBAkMOkF2ZGEgZGVsIE1lZGl0ZXJyYW5lbyBFdG9yYmlkZWEgMTQgLSAwMTAx +MCBWaXRvcmlhLUdhc3RlaXowDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC +AQYwHQYDVR0OBBYEFB0cZQ6o8iV7tJHP5LGx5r1VdGwFMA0GCSqGSIb3DQEBCwUA +A4ICAQB4pgwWSp9MiDrAyw6lFn2fuUhfGI8NYjb2zRlrrKvV9pF9rnHzP7MOeIWb +laQnIUdCSnxIOvVFfLMMjlF4rJUT3sb9fbgakEyrkgPH7UIBzg/YsfqikuFgba56 +awmqxinuaElnMIAkejEWOVt+8Rwu3WwJrfIxwYJOubv5vr8qhT/AQKM6WfxZSzwo +JNu0FXWuDYi6LnPAvViH5ULy617uHjAimcs30cQhbIHsvm0m5hzkQiCeR7Csg1lw +LDXWrzY0tM07+DKo7+N4ifuNRSzanLh+QBxh5z6ikixL8s36mLYp//Pye6kfLqCT +VyvehQP5aTfLnnhqBbTFMXiJ7HqnheG5ezzevh55hM6fcA5ZwjUukCox2eRFekGk +LhObNA5me0mrZJfQRsN5nXJQY6aYWwa9SG3YOYNw6DXwBdGqvOPbyALqfP2C2sJb +UjWumDqtujWTI6cfSN01RpiyEGjkpTHCClguGYEQyVB1/OpaFs4R1+7vUIgtYf8/ +QnMFlEPVjjxOAToZpR9GTnfQXeWBIiGH/pR9hNiTrdZoQ0iy2+tzJOeRf1SktoA+ +naM8THLCV8Sg1Mw4J87VBp6iSNnpn86CcDaTmjvfliHjWbcM2pE38P1ZWrOZyGls +QyYBNWNgVYkDOnXYukrZVP/u3oDYLdE41V4tC5h9Pmzb/CaIxw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIE5jCCA86gAwIBAgIEO45L/DANBgkqhkiG9w0BAQUFADBdMRgwFgYJKoZIhvcN +AQkBFglwa2lAc2suZWUxCzAJBgNVBAYTAkVFMSIwIAYDVQQKExlBUyBTZXJ0aWZp +dHNlZXJpbWlza2Vza3VzMRAwDgYDVQQDEwdKdXVyLVNLMB4XDTAxMDgzMDE0MjMw +MVoXDTE2MDgyNjE0MjMwMVowXTEYMBYGCSqGSIb3DQEJARYJcGtpQHNrLmVlMQsw +CQYDVQQGEwJFRTEiMCAGA1UEChMZQVMgU2VydGlmaXRzZWVyaW1pc2tlc2t1czEQ +MA4GA1UEAxMHSnV1ci1TSzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +AIFxNj4zB9bjMI0TfncyRsvPGbJgMUaXhvSYRqTCZUXP00B841oiqBB4M8yIsdOB +SvZiF3tfTQou0M+LI+5PAk676w7KvRhj6IAcjeEcjT3g/1tf6mTll+g/mX8MCgkz +ABpTpyHhOEvWgxutr2TC+Rx6jGZITWYfGAriPrsfB2WThbkasLnE+w0R9vXW+RvH +LCu3GFH+4Hv2qEivbDtPL+/40UceJlfwUR0zlv/vWT3aTdEVNMfqPxZIe5EcgEMP +PbgFPtGzlc3Yyg/CQ2fbt5PgIoIuvvVoKIO5wTtpeyDaTpxt4brNj3pssAki14sL +2xzVWiZbDcDq5WDQn/413z8CAwEAAaOCAawwggGoMA8GA1UdEwEB/wQFMAMBAf8w +ggEWBgNVHSAEggENMIIBCTCCAQUGCisGAQQBzh8BAQEwgfYwgdAGCCsGAQUFBwIC +MIHDHoHAAFMAZQBlACAAcwBlAHIAdABpAGYAaQBrAGEAYQB0ACAAbwBuACAAdgDk +AGwAagBhAHMAdABhAHQAdQBkACAAQQBTAC0AaQBzACAAUwBlAHIAdABpAGYAaQB0 +AHMAZQBlAHIAaQBtAGkAcwBrAGUAcwBrAHUAcwAgAGEAbABhAG0ALQBTAEsAIABz +AGUAcgB0AGkAZgBpAGsAYQBhAHQAaQBkAGUAIABrAGkAbgBuAGkAdABhAG0AaQBz +AGUAawBzMCEGCCsGAQUFBwIBFhVodHRwOi8vd3d3LnNrLmVlL2Nwcy8wKwYDVR0f +BCQwIjAgoB6gHIYaaHR0cDovL3d3dy5zay5lZS9qdXVyL2NybC8wHQYDVR0OBBYE +FASqekej5ImvGs8KQKcYP2/v6X2+MB8GA1UdIwQYMBaAFASqekej5ImvGs8KQKcY +P2/v6X2+MA4GA1UdDwEB/wQEAwIB5jANBgkqhkiG9w0BAQUFAAOCAQEAe8EYlFOi +CfP+JmeaUOTDBS8rNXiRTHyoERF5TElZrMj3hWVcRrs7EKACr81Ptcw2Kuxd/u+g +kcm2k298gFTsxwhwDY77guwqYHhpNjbRxZyLabVAyJRld/JXIWY7zoVAtjNjGr95 +HvxcHdMdkxuLDF2FvZkwMhgJkVLpfKG6/2SSmuz+Ne6ML678IIbsSt4beDI3poHS +na9aEhbKmVv8b20OxaAehsmR0FyYgl9jDIpaq9iVpszLita/ZEuOyoqysOkhMp6q +qIWYNIE5ITuoOlIyPfZrN4YGWhWY3PARZv40ILcD9EEQfTmEeZZyY7aWAuVrua0Z +TbvGRNs2yyqcjg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIHqDCCBpCgAwIBAgIRAMy4579OKRr9otxmpRwsDxEwDQYJKoZIhvcNAQEFBQAw +cjELMAkGA1UEBhMCSFUxETAPBgNVBAcTCEJ1ZGFwZXN0MRYwFAYDVQQKEw1NaWNy +b3NlYyBMdGQuMRQwEgYDVQQLEwtlLVN6aWdubyBDQTEiMCAGA1UEAxMZTWljcm9z +ZWMgZS1Temlnbm8gUm9vdCBDQTAeFw0wNTA0MDYxMjI4NDRaFw0xNzA0MDYxMjI4 +NDRaMHIxCzAJBgNVBAYTAkhVMREwDwYDVQQHEwhCdWRhcGVzdDEWMBQGA1UEChMN +TWljcm9zZWMgTHRkLjEUMBIGA1UECxMLZS1Temlnbm8gQ0ExIjAgBgNVBAMTGU1p +Y3Jvc2VjIGUtU3ppZ25vIFJvb3QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAw +ggEKAoIBAQDtyADVgXvNOABHzNuEwSFpLHSQDCHZU4ftPkNEU6+r+ICbPHiN1I2u +uO/TEdyB5s87lozWbxXGd36hL+BfkrYn13aaHUM86tnsL+4582pnS4uCzyL4ZVX+ +LMsvfUh6PXX5qqAnu3jCBspRwn5mS6/NoqdNAoI/gqyFxuEPkEeZlApxcpMqyabA +vjxWTHOSJ/FrtfX9/DAFYJLG65Z+AZHCabEeHXtTRbjcQR/Ji3HWVBTji1R4P770 +Yjtb9aPs1ZJ04nQw7wHb4dSrmZsqa/i9phyGI0Jf7Enemotb9HI6QMVJPqW+jqpx +62z69Rrkav17fVVA71hu5tnVvCSrwe+3AgMBAAGjggQ3MIIEMzBnBggrBgEFBQcB +AQRbMFkwKAYIKwYBBQUHMAGGHGh0dHBzOi8vcmNhLmUtc3ppZ25vLmh1L29jc3Aw +LQYIKwYBBQUHMAKGIWh0dHA6Ly93d3cuZS1zemlnbm8uaHUvUm9vdENBLmNydDAP +BgNVHRMBAf8EBTADAQH/MIIBcwYDVR0gBIIBajCCAWYwggFiBgwrBgEEAYGoGAIB +AQEwggFQMCgGCCsGAQUFBwIBFhxodHRwOi8vd3d3LmUtc3ppZ25vLmh1L1NaU1ov +MIIBIgYIKwYBBQUHAgIwggEUHoIBEABBACAAdABhAG4A+gBzAO0AdAB2AOEAbgB5 +ACAA6QByAHQAZQBsAG0AZQB6AOkAcwDpAGgAZQB6ACAA6QBzACAAZQBsAGYAbwBn +AGEAZADhAHMA4QBoAG8AegAgAGEAIABTAHoAbwBsAGcA4QBsAHQAYQB0APMAIABT +AHoAbwBsAGcA4QBsAHQAYQB0AOEAcwBpACAAUwB6AGEAYgDhAGwAeQB6AGEAdABh +ACAAcwB6AGUAcgBpAG4AdAAgAGsAZQBsAGwAIABlAGwAagDhAHIAbgBpADoAIABo +AHQAdABwADoALwAvAHcAdwB3AC4AZQAtAHMAegBpAGcAbgBvAC4AaAB1AC8AUwBa +AFMAWgAvMIHIBgNVHR8EgcAwgb0wgbqggbeggbSGIWh0dHA6Ly93d3cuZS1zemln +bm8uaHUvUm9vdENBLmNybIaBjmxkYXA6Ly9sZGFwLmUtc3ppZ25vLmh1L0NOPU1p +Y3Jvc2VjJTIwZS1Temlnbm8lMjBSb290JTIwQ0EsT1U9ZS1Temlnbm8lMjBDQSxP +PU1pY3Jvc2VjJTIwTHRkLixMPUJ1ZGFwZXN0LEM9SFU/Y2VydGlmaWNhdGVSZXZv +Y2F0aW9uTGlzdDtiaW5hcnkwDgYDVR0PAQH/BAQDAgEGMIGWBgNVHREEgY4wgYuB +EGluZm9AZS1zemlnbm8uaHWkdzB1MSMwIQYDVQQDDBpNaWNyb3NlYyBlLVN6aWdu +w7MgUm9vdCBDQTEWMBQGA1UECwwNZS1TemlnbsOzIEhTWjEWMBQGA1UEChMNTWlj +cm9zZWMgS2Z0LjERMA8GA1UEBxMIQnVkYXBlc3QxCzAJBgNVBAYTAkhVMIGsBgNV +HSMEgaQwgaGAFMegSXUWYYTbMUuE0vE3QJDvTtz3oXakdDByMQswCQYDVQQGEwJI +VTERMA8GA1UEBxMIQnVkYXBlc3QxFjAUBgNVBAoTDU1pY3Jvc2VjIEx0ZC4xFDAS +BgNVBAsTC2UtU3ppZ25vIENBMSIwIAYDVQQDExlNaWNyb3NlYyBlLVN6aWdubyBS +b290IENBghEAzLjnv04pGv2i3GalHCwPETAdBgNVHQ4EFgQUx6BJdRZhhNsxS4TS +8TdAkO9O3PcwDQYJKoZIhvcNAQEFBQADggEBANMTnGZjWS7KXHAM/IO8VbH0jgds +ZifOwTsgqRy7RlRw7lrMoHfqaEQn6/Ip3Xep1fvj1KcExJW4C+FEaGAHQzAxQmHl +7tnlJNUb3+FKG6qfx1/4ehHqE5MAyopYse7tDk2016g2JnzgOsHVV4Lxdbb9iV/a +86g4nzUGCM4ilb7N1fy+W955a9x6qWVmvrElWl/tftOsRm1M9DKHtCAE4Gx4sHfR +hUZLphK3dehKyVZs15KrnfVJONJPU+NVkBHbmJbGSfI+9J8b4PeI3CVimUTYc78/ +MPMMNz7UwiiAc7EBt51alhQBS6kRnSlqLtBdgcDPsiBDxwPgN05dCtxZICU= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIECjCCAvKgAwIBAgIJAMJ+QwRORz8ZMA0GCSqGSIb3DQEBCwUAMIGCMQswCQYD +VQQGEwJIVTERMA8GA1UEBwwIQnVkYXBlc3QxFjAUBgNVBAoMDU1pY3Jvc2VjIEx0 +ZC4xJzAlBgNVBAMMHk1pY3Jvc2VjIGUtU3ppZ25vIFJvb3QgQ0EgMjAwOTEfMB0G +CSqGSIb3DQEJARYQaW5mb0BlLXN6aWduby5odTAeFw0wOTA2MTYxMTMwMThaFw0y +OTEyMzAxMTMwMThaMIGCMQswCQYDVQQGEwJIVTERMA8GA1UEBwwIQnVkYXBlc3Qx +FjAUBgNVBAoMDU1pY3Jvc2VjIEx0ZC4xJzAlBgNVBAMMHk1pY3Jvc2VjIGUtU3pp +Z25vIFJvb3QgQ0EgMjAwOTEfMB0GCSqGSIb3DQEJARYQaW5mb0BlLXN6aWduby5o +dTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOn4j/NjrdqG2KfgQvvP +kd6mJviZpWNwrZuuyjNAfW2WbqEORO7hE52UQlKavXWFdCyoDh2Tthi3jCyoz/tc +cbna7P7ofo/kLx2yqHWH2Leh5TvPmUpG0IMZfcChEhyVbUr02MelTTMuhTlAdX4U +fIASmFDHQWe4oIBhVKZsTh/gnQ4H6cm6M+f+wFUoLAKApxn1ntxVUwOXewdI/5n7 +N4okxFnMUBBjjqqpGrCEGob5X7uxUG6k0QrM1XF+H6cbfPVTbiJfyyvm1HxdrtbC +xkzlBQHZ7Vf8wSN5/PrIJIOV87VqUQHQd9bpEqH5GoP7ghu5sJf0dgYzQ0mg/wu1 ++rUCAwEAAaOBgDB+MA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0G +A1UdDgQWBBTLD8bfQkPMPcu1SCOhGnqmKrs0aDAfBgNVHSMEGDAWgBTLD8bfQkPM +Pcu1SCOhGnqmKrs0aDAbBgNVHREEFDASgRBpbmZvQGUtc3ppZ25vLmh1MA0GCSqG +SIb3DQEBCwUAA4IBAQDJ0Q5eLtXMs3w+y/w9/w0olZMEyL/azXm4Q5DwpL7v8u8h +mLzU1F0G9u5C7DBsoKqpyvGvivo/C3NqPuouQH4frlRheesuCDfXI/OMn74dseGk +ddug4lQUsbocKaQY9hK6ohQU4zE1yED/t+AFdlfBHFny+L/k7SViXITwfn4fs775 +tyERzAMBVnCnEJIeGzSBHq2cGsMEPO0CYdYeBvNfOofyK/FFh+U9rNHHV4S9a67c +2Pm2G2JwCz02yULyMtd6YebS2z3PyKnJm9zbWETXbzivf3jTo60adbocwTZ8jx5t +HMN1Rq41Bab2XD0h7lbwyYIiLXpUq3DDfSJlgnCW +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEFTCCAv2gAwIBAgIGSUEs5AAQMA0GCSqGSIb3DQEBCwUAMIGnMQswCQYDVQQG +EwJIVTERMA8GA1UEBwwIQnVkYXBlc3QxFTATBgNVBAoMDE5ldExvY2sgS2Z0LjE3 +MDUGA1UECwwuVGFuw7pzw610dsOhbnlraWFkw7NrIChDZXJ0aWZpY2F0aW9uIFNl +cnZpY2VzKTE1MDMGA1UEAwwsTmV0TG9jayBBcmFueSAoQ2xhc3MgR29sZCkgRsWR +dGFuw7pzw610dsOhbnkwHhcNMDgxMjExMTUwODIxWhcNMjgxMjA2MTUwODIxWjCB +pzELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MRUwEwYDVQQKDAxOZXRM +b2NrIEtmdC4xNzA1BgNVBAsMLlRhbsO6c8OtdHbDoW55a2lhZMOzayAoQ2VydGlm +aWNhdGlvbiBTZXJ2aWNlcykxNTAzBgNVBAMMLE5ldExvY2sgQXJhbnkgKENsYXNz +IEdvbGQpIEbFkXRhbsO6c8OtdHbDoW55MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A +MIIBCgKCAQEAxCRec75LbRTDofTjl5Bu0jBFHjzuZ9lk4BqKf8owyoPjIMHj9DrT +lF8afFttvzBPhCf2nx9JvMaZCpDyD/V/Q4Q3Y1GLeqVw/HpYzY6b7cNGbIRwXdrz +AZAj/E4wqX7hJ2Pn7WQ8oLjJM2P+FpD/sLj916jAwJRDC7bVWaaeVtAkH3B5r9s5 +VA1lddkVQZQBr17s9o3x/61k/iCa11zr/qYfCGSji3ZVrR47KGAuhyXoqq8fxmRG +ILdwfzzeSNuWU7c5d+Qa4scWhHaXWy+7GRWF+GmF9ZmnqfI0p6m2pgP8b4Y9VHx2 +BJtr+UBdADTHLpl1neWIA6pN+APSQnbAGwIDAKiLo0UwQzASBgNVHRMBAf8ECDAG +AQH/AgEEMA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUzPpnk/C2uNClwB7zU/2M +U9+D15YwDQYJKoZIhvcNAQELBQADggEBAKt/7hwWqZw8UQCgwBEIBaeZ5m8BiFRh +bvG5GK1Krf6BQCOUL/t1fC8oS2IkgYIL9WHxHG64YTjrgfpioTtaYtOUZcTh5m2C ++C8lcLIhJsFyUR+MLMOEkMNaj7rP9KdlpeuY0fsFskZ1FSNqb4VjMIDw1Z4fKRzC +bLBQWV2QWzuoDTDPv31/zvGdg73JRm4gpvlhUbohL3u+pRVjodSVh/GeufOJ8z2F +uLjbvrW5KfnaNwUASZQDhETnv0Mxz3WLJdH0pmT1kvarBes96aULNmLazAZfNou2 +XjG4Kvte9nHfRCaexOYNkbQudZWAUWpLMKawYqGT8ZvYzsRjdT9ZR7E= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFSzCCBLSgAwIBAgIBaTANBgkqhkiG9w0BAQQFADCBmTELMAkGA1UEBhMCSFUx +ETAPBgNVBAcTCEJ1ZGFwZXN0MScwJQYDVQQKEx5OZXRMb2NrIEhhbG96YXRiaXp0 +b25zYWdpIEtmdC4xGjAYBgNVBAsTEVRhbnVzaXR2YW55a2lhZG9rMTIwMAYDVQQD +EylOZXRMb2NrIFV6bGV0aSAoQ2xhc3MgQikgVGFudXNpdHZhbnlraWFkbzAeFw05 +OTAyMjUxNDEwMjJaFw0xOTAyMjAxNDEwMjJaMIGZMQswCQYDVQQGEwJIVTERMA8G +A1UEBxMIQnVkYXBlc3QxJzAlBgNVBAoTHk5ldExvY2sgSGFsb3phdGJpenRvbnNh +Z2kgS2Z0LjEaMBgGA1UECxMRVGFudXNpdHZhbnlraWFkb2sxMjAwBgNVBAMTKU5l +dExvY2sgVXpsZXRpIChDbGFzcyBCKSBUYW51c2l0dmFueWtpYWRvMIGfMA0GCSqG +SIb3DQEBAQUAA4GNADCBiQKBgQCx6gTsIKAjwo84YM/HRrPVG/77uZmeBNwcf4xK +gZjupNTKihe5In+DCnVMm8Bp2GQ5o+2So/1bXHQawEfKOml2mrriRBf8TKPV/riX +iK+IA4kfpPIEPsgHC+b5sy96YhQJRhTKZPWLgLViqNhr1nGTLbO/CVRY7QbrqHvc +Q7GhaQIDAQABo4ICnzCCApswEgYDVR0TAQH/BAgwBgEB/wIBBDAOBgNVHQ8BAf8E +BAMCAAYwEQYJYIZIAYb4QgEBBAQDAgAHMIICYAYJYIZIAYb4QgENBIICURaCAk1G +SUdZRUxFTSEgRXplbiB0YW51c2l0dmFueSBhIE5ldExvY2sgS2Z0LiBBbHRhbGFu +b3MgU3pvbGdhbHRhdGFzaSBGZWx0ZXRlbGVpYmVuIGxlaXJ0IGVsamFyYXNvayBh +bGFwamFuIGtlc3p1bHQuIEEgaGl0ZWxlc2l0ZXMgZm9seWFtYXRhdCBhIE5ldExv +Y2sgS2Z0LiB0ZXJtZWtmZWxlbG9zc2VnLWJpenRvc2l0YXNhIHZlZGkuIEEgZGln +aXRhbGlzIGFsYWlyYXMgZWxmb2dhZGFzYW5hayBmZWx0ZXRlbGUgYXogZWxvaXJ0 +IGVsbGVub3J6ZXNpIGVsamFyYXMgbWVndGV0ZWxlLiBBeiBlbGphcmFzIGxlaXJh +c2EgbWVndGFsYWxoYXRvIGEgTmV0TG9jayBLZnQuIEludGVybmV0IGhvbmxhcGph +biBhIGh0dHBzOi8vd3d3Lm5ldGxvY2submV0L2RvY3MgY2ltZW4gdmFneSBrZXJo +ZXRvIGF6IGVsbGVub3J6ZXNAbmV0bG9jay5uZXQgZS1tYWlsIGNpbWVuLiBJTVBP +UlRBTlQhIFRoZSBpc3N1YW5jZSBhbmQgdGhlIHVzZSBvZiB0aGlzIGNlcnRpZmlj +YXRlIGlzIHN1YmplY3QgdG8gdGhlIE5ldExvY2sgQ1BTIGF2YWlsYWJsZSBhdCBo +dHRwczovL3d3dy5uZXRsb2NrLm5ldC9kb2NzIG9yIGJ5IGUtbWFpbCBhdCBjcHNA +bmV0bG9jay5uZXQuMA0GCSqGSIb3DQEBBAUAA4GBAATbrowXr/gOkDFOzT4JwG06 +sPgzTEdM43WIEJessDgVkcYplswhwG08pXTP2IKlOcNl40JwuyKQ433bNXbhoLXa +n3BukxowOR0w2y7jfLKRstE3Kfq51hdcR0/jHTjrn9V7lagonhVK0dHQKwCXoOKS +NitjrFgBazMpUIaD8QFI +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFTzCCBLigAwIBAgIBaDANBgkqhkiG9w0BAQQFADCBmzELMAkGA1UEBhMCSFUx +ETAPBgNVBAcTCEJ1ZGFwZXN0MScwJQYDVQQKEx5OZXRMb2NrIEhhbG96YXRiaXp0 +b25zYWdpIEtmdC4xGjAYBgNVBAsTEVRhbnVzaXR2YW55a2lhZG9rMTQwMgYDVQQD +EytOZXRMb2NrIEV4cHJlc3N6IChDbGFzcyBDKSBUYW51c2l0dmFueWtpYWRvMB4X +DTk5MDIyNTE0MDgxMVoXDTE5MDIyMDE0MDgxMVowgZsxCzAJBgNVBAYTAkhVMREw +DwYDVQQHEwhCdWRhcGVzdDEnMCUGA1UEChMeTmV0TG9jayBIYWxvemF0Yml6dG9u +c2FnaSBLZnQuMRowGAYDVQQLExFUYW51c2l0dmFueWtpYWRvazE0MDIGA1UEAxMr +TmV0TG9jayBFeHByZXNzeiAoQ2xhc3MgQykgVGFudXNpdHZhbnlraWFkbzCBnzAN +BgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA6+ywbGGKIyWvYCDj2Z/8kwvbXY2wobNA +OoLO/XXgeDIDhlqGlZHtU/qdQPzm6N3ZW3oDvV3zOwzDUXmbrVWg6dADEK8KuhRC +2VImESLH0iDMgqSaqf64gXadarfSNnU+sYYJ9m5tfk63euyucYT2BDMIJTLrdKwW +RMbkQJMdf60CAwEAAaOCAp8wggKbMBIGA1UdEwEB/wQIMAYBAf8CAQQwDgYDVR0P +AQH/BAQDAgAGMBEGCWCGSAGG+EIBAQQEAwIABzCCAmAGCWCGSAGG+EIBDQSCAlEW +ggJNRklHWUVMRU0hIEV6ZW4gdGFudXNpdHZhbnkgYSBOZXRMb2NrIEtmdC4gQWx0 +YWxhbm9zIFN6b2xnYWx0YXRhc2kgRmVsdGV0ZWxlaWJlbiBsZWlydCBlbGphcmFz +b2sgYWxhcGphbiBrZXN6dWx0LiBBIGhpdGVsZXNpdGVzIGZvbHlhbWF0YXQgYSBO +ZXRMb2NrIEtmdC4gdGVybWVrZmVsZWxvc3NlZy1iaXp0b3NpdGFzYSB2ZWRpLiBB +IGRpZ2l0YWxpcyBhbGFpcmFzIGVsZm9nYWRhc2FuYWsgZmVsdGV0ZWxlIGF6IGVs +b2lydCBlbGxlbm9yemVzaSBlbGphcmFzIG1lZ3RldGVsZS4gQXogZWxqYXJhcyBs +ZWlyYXNhIG1lZ3RhbGFsaGF0byBhIE5ldExvY2sgS2Z0LiBJbnRlcm5ldCBob25s +YXBqYW4gYSBodHRwczovL3d3dy5uZXRsb2NrLm5ldC9kb2NzIGNpbWVuIHZhZ3kg +a2VyaGV0byBheiBlbGxlbm9yemVzQG5ldGxvY2submV0IGUtbWFpbCBjaW1lbi4g +SU1QT1JUQU5UISBUaGUgaXNzdWFuY2UgYW5kIHRoZSB1c2Ugb2YgdGhpcyBjZXJ0 +aWZpY2F0ZSBpcyBzdWJqZWN0IHRvIHRoZSBOZXRMb2NrIENQUyBhdmFpbGFibGUg +YXQgaHR0cHM6Ly93d3cubmV0bG9jay5uZXQvZG9jcyBvciBieSBlLW1haWwgYXQg +Y3BzQG5ldGxvY2submV0LjANBgkqhkiG9w0BAQQFAAOBgQAQrX/XDDKACtiG8XmY +ta3UzbM2xJZIwVzNmtkFLp++UOv0JhQQLdRmF/iewSf98e3ke0ugbLWrmldwpu2g +pO0u9f38vf5NNwgMvOOWgyL1SRt/Syu0VMGAfJlOHdCM7tCs5ZL6dVb+ZKATj7i4 +Fp1hBWeAyNDYpQcCNJgEjTME1A== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIGfTCCBWWgAwIBAgICAQMwDQYJKoZIhvcNAQEEBQAwga8xCzAJBgNVBAYTAkhV +MRAwDgYDVQQIEwdIdW5nYXJ5MREwDwYDVQQHEwhCdWRhcGVzdDEnMCUGA1UEChMe +TmV0TG9jayBIYWxvemF0Yml6dG9uc2FnaSBLZnQuMRowGAYDVQQLExFUYW51c2l0 +dmFueWtpYWRvazE2MDQGA1UEAxMtTmV0TG9jayBLb3pqZWd5em9pIChDbGFzcyBB +KSBUYW51c2l0dmFueWtpYWRvMB4XDTk5MDIyNDIzMTQ0N1oXDTE5MDIxOTIzMTQ0 +N1owga8xCzAJBgNVBAYTAkhVMRAwDgYDVQQIEwdIdW5nYXJ5MREwDwYDVQQHEwhC +dWRhcGVzdDEnMCUGA1UEChMeTmV0TG9jayBIYWxvemF0Yml6dG9uc2FnaSBLZnQu +MRowGAYDVQQLExFUYW51c2l0dmFueWtpYWRvazE2MDQGA1UEAxMtTmV0TG9jayBL +b3pqZWd5em9pIChDbGFzcyBBKSBUYW51c2l0dmFueWtpYWRvMIIBIjANBgkqhkiG +9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvHSMD7tM9DceqQWC2ObhbHDqeLVu0ThEDaiD +zl3S1tWBxdRL51uUcCbbO51qTGL3cfNk1mE7PetzozfZz+qMkjvN9wfcZnSX9EUi +3fRc4L9t875lM+QVOr/bmJBVOMTtplVjC7B4BPTjbsE/jvxReB+SnoPC/tmwqcm8 +WgD/qaiYdPv2LD4VOQ22BFWoDpggQrOxJa1+mm9dU7GrDPzr4PN6s6iz/0b2Y6LY +Oph7tqyF/7AlT3Rj5xMHpQqPBffAZG9+pyeAlt7ULoZgx2srXnN7F+eRP2QM2Esi +NCubMvJIH5+hCoR64sKtlz2O1cH5VqNQ6ca0+pii7pXmKgOM3wIDAQABo4ICnzCC +ApswDgYDVR0PAQH/BAQDAgAGMBIGA1UdEwEB/wQIMAYBAf8CAQQwEQYJYIZIAYb4 +QgEBBAQDAgAHMIICYAYJYIZIAYb4QgENBIICURaCAk1GSUdZRUxFTSEgRXplbiB0 +YW51c2l0dmFueSBhIE5ldExvY2sgS2Z0LiBBbHRhbGFub3MgU3pvbGdhbHRhdGFz +aSBGZWx0ZXRlbGVpYmVuIGxlaXJ0IGVsamFyYXNvayBhbGFwamFuIGtlc3p1bHQu +IEEgaGl0ZWxlc2l0ZXMgZm9seWFtYXRhdCBhIE5ldExvY2sgS2Z0LiB0ZXJtZWtm +ZWxlbG9zc2VnLWJpenRvc2l0YXNhIHZlZGkuIEEgZGlnaXRhbGlzIGFsYWlyYXMg +ZWxmb2dhZGFzYW5hayBmZWx0ZXRlbGUgYXogZWxvaXJ0IGVsbGVub3J6ZXNpIGVs +amFyYXMgbWVndGV0ZWxlLiBBeiBlbGphcmFzIGxlaXJhc2EgbWVndGFsYWxoYXRv +IGEgTmV0TG9jayBLZnQuIEludGVybmV0IGhvbmxhcGphbiBhIGh0dHBzOi8vd3d3 +Lm5ldGxvY2submV0L2RvY3MgY2ltZW4gdmFneSBrZXJoZXRvIGF6IGVsbGVub3J6 +ZXNAbmV0bG9jay5uZXQgZS1tYWlsIGNpbWVuLiBJTVBPUlRBTlQhIFRoZSBpc3N1 +YW5jZSBhbmQgdGhlIHVzZSBvZiB0aGlzIGNlcnRpZmljYXRlIGlzIHN1YmplY3Qg +dG8gdGhlIE5ldExvY2sgQ1BTIGF2YWlsYWJsZSBhdCBodHRwczovL3d3dy5uZXRs +b2NrLm5ldC9kb2NzIG9yIGJ5IGUtbWFpbCBhdCBjcHNAbmV0bG9jay5uZXQuMA0G +CSqGSIb3DQEBBAUAA4IBAQBIJEb3ulZv+sgoA0BO5TE5ayZrU3/b39/zcT0mwBQO +xmd7I6gMc90Bu8bKbjc5VdXHjFYgDigKDtIqpLBJUsY4B/6+CgmM0ZjPytoUMaFP +0jn8DxEsQ8Pdq5PHVT5HfBgaANzze9jyf1JsIPQLX2lS9O74silg6+NJMSEN1rUQ +QeJBCWziGppWS3cC9qCbmieH6FUpccKQn0V4GuEVZD3QDtigdp+uxdAu6tYPVuxk +f1qbFFgBJ34TUMdrKuZoPL9coAob4Q566eKAw+np9v1sEZ7Q5SgnK1QyQhSCdeZK +8CtmdWOMovsEPoMOmzbwGOQmIMOM8CgHrTwXZoi1/baI +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIID5jCCAs6gAwIBAgIQV8szb8JcFuZHFhfjkDFo4DANBgkqhkiG9w0BAQUFADBi +MQswCQYDVQQGEwJVUzEhMB8GA1UEChMYTmV0d29yayBTb2x1dGlvbnMgTC5MLkMu +MTAwLgYDVQQDEydOZXR3b3JrIFNvbHV0aW9ucyBDZXJ0aWZpY2F0ZSBBdXRob3Jp +dHkwHhcNMDYxMjAxMDAwMDAwWhcNMjkxMjMxMjM1OTU5WjBiMQswCQYDVQQGEwJV +UzEhMB8GA1UEChMYTmV0d29yayBTb2x1dGlvbnMgTC5MLkMuMTAwLgYDVQQDEydO +ZXR3b3JrIFNvbHV0aW9ucyBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkwggEiMA0GCSqG +SIb3DQEBAQUAA4IBDwAwggEKAoIBAQDkvH6SMG3G2I4rC7xGzuAnlt7e+foS0zwz +c7MEL7xxjOWftiJgPl9dzgn/ggwbmlFQGiaJ3dVhXRncEg8tCqJDXRfQNJIg6nPP +OCwGJgl6cvf6UDL4wpPTaaIjzkGxzOTVHzbRijr4jGPiFFlp7Q3Tf2vouAPlT2rl +mGNpSAW+Lv8ztumXWWn4Zxmuk2GWRBXTcrA/vGp97Eh/jcOrqnErU2lBUzS1sLnF +BgrEsEX1QV1uiUV7PTsmjHTC5dLRfbIR1PtYMiKagMnc/Qzpf14Dl847ABSHJ3A4 +qY5usyd2mFHgBeMhqxrVhSI8KbWaFsWAqPS7azCPL0YCorEMIuDTAgMBAAGjgZcw +gZQwHQYDVR0OBBYEFCEwyfsA106Y2oeqKtCnLrFAMadMMA4GA1UdDwEB/wQEAwIB +BjAPBgNVHRMBAf8EBTADAQH/MFIGA1UdHwRLMEkwR6BFoEOGQWh0dHA6Ly9jcmwu +bmV0c29sc3NsLmNvbS9OZXR3b3JrU29sdXRpb25zQ2VydGlmaWNhdGVBdXRob3Jp +dHkuY3JsMA0GCSqGSIb3DQEBBQUAA4IBAQC7rkvnt1frf6ott3NHhWrB5KUd5Oc8 +6fRZZXe1eltajSU24HqXLjjAV2CDmAaDn7l2em5Q4LqILPxFzBiwmZVRDuwduIj/ +h1AcgsLj4DKAv6ALR8jDMe+ZZzKATxcheQxpXN5eNK4CtSbqUN9/GGUsyfJj4akH +/nxxH2szJGoeBfcFaMBqEssuXmHLrijTfsK0ZpEmXzwuJF/LWA/rKOyvEZbz3Htv +wKeI8lN3s2Berq4o2jUsbzRF0ybh3uxbTydrFny9RAQYgrOJeRcQcT16ohZO9QHN +pGxlaKFJdlxDydi8NmdspZS11My5vWo1ViHe2MPr+8ukYEywVaCge1ey +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIID8TCCAtmgAwIBAgIQQT1yx/RrH4FDffHSKFTfmjANBgkqhkiG9w0BAQUFADCB +ijELMAkGA1UEBhMCQ0gxEDAOBgNVBAoTB1dJU2VLZXkxGzAZBgNVBAsTEkNvcHly +aWdodCAoYykgMjAwNTEiMCAGA1UECxMZT0lTVEUgRm91bmRhdGlvbiBFbmRvcnNl +ZDEoMCYGA1UEAxMfT0lTVEUgV0lTZUtleSBHbG9iYWwgUm9vdCBHQSBDQTAeFw0w +NTEyMTExNjAzNDRaFw0zNzEyMTExNjA5NTFaMIGKMQswCQYDVQQGEwJDSDEQMA4G +A1UEChMHV0lTZUtleTEbMBkGA1UECxMSQ29weXJpZ2h0IChjKSAyMDA1MSIwIAYD +VQQLExlPSVNURSBGb3VuZGF0aW9uIEVuZG9yc2VkMSgwJgYDVQQDEx9PSVNURSBX +SVNlS2V5IEdsb2JhbCBSb290IEdBIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A +MIIBCgKCAQEAy0+zAJs9Nt350UlqaxBJH+zYK7LG+DKBKUOVTJoZIyEVRd7jyBxR +VVuuk+g3/ytr6dTqvirdqFEr12bDYVxgAsj1znJ7O7jyTmUIms2kahnBAbtzptf2 +w93NvKSLtZlhuAGio9RN1AU9ka34tAhxZK9w8RxrfvbDd50kc3vkDIzh2TbhmYsF +mQvtRTEJysIA2/dyoJaqlYfQjse2YXMNdmaM3Bu0Y6Kff5MTMPGhJ9vZ/yxViJGg +4E8HsChWjBgbl0SOid3gF27nKu+POQoxhILYQBRJLnpB5Kf+42TMwVlxSywhp1t9 +4B3RLoGbw9ho972WG6xwsRYUC9tguSYBBQIDAQABo1EwTzALBgNVHQ8EBAMCAYYw +DwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUswN+rja8sHnR3JQmthG+IbJphpQw +EAYJKwYBBAGCNxUBBAMCAQAwDQYJKoZIhvcNAQEFBQADggEBAEuh/wuHbrP5wUOx +SPMowB0uyQlB+pQAHKSkq0lPjz0e701vvbyk9vImMMkQyh2I+3QZH4VFvbBsUfk2 +ftv1TDI6QU9bR8/oCy22xBmddMVHxjtqD6wU2zz0c5ypBd8A3HR4+vg1YFkCExh8 +vPtNsCBtQ7tgMHpnM1zFmdH4LTlSc/uMqpclXHLZCB6rTjzjgTGfA6b7wP4piFXa +hNVQA7bihKOmNqoROgHhGEvWRGizPflTdISzRpFGlgC3gCy24eMQ4tui5yiPAZZi +Fj4A4xylNoEYokxSdsARo27mHbrjWr42U8U+dY+GaSlYU7Wcu2+fXMUY7N0v4ZjJ +/L7fCg0= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIJhjCCB26gAwIBAgIBCzANBgkqhkiG9w0BAQsFADCCAR4xPjA8BgNVBAMTNUF1 +dG9yaWRhZCBkZSBDZXJ0aWZpY2FjaW9uIFJhaXogZGVsIEVzdGFkbyBWZW5lem9s +YW5vMQswCQYDVQQGEwJWRTEQMA4GA1UEBxMHQ2FyYWNhczEZMBcGA1UECBMQRGlz +dHJpdG8gQ2FwaXRhbDE2MDQGA1UEChMtU2lzdGVtYSBOYWNpb25hbCBkZSBDZXJ0 +aWZpY2FjaW9uIEVsZWN0cm9uaWNhMUMwQQYDVQQLEzpTdXBlcmludGVuZGVuY2lh +IGRlIFNlcnZpY2lvcyBkZSBDZXJ0aWZpY2FjaW9uIEVsZWN0cm9uaWNhMSUwIwYJ +KoZIhvcNAQkBFhZhY3JhaXpAc3VzY2VydGUuZ29iLnZlMB4XDTEwMTIyODE2NTEw +MFoXDTIwMTIyNTIzNTk1OVowgdExJjAkBgkqhkiG9w0BCQEWF2NvbnRhY3RvQHBy +b2NlcnQubmV0LnZlMQ8wDQYDVQQHEwZDaGFjYW8xEDAOBgNVBAgTB01pcmFuZGEx +KjAoBgNVBAsTIVByb3ZlZWRvciBkZSBDZXJ0aWZpY2Fkb3MgUFJPQ0VSVDE2MDQG +A1UEChMtU2lzdGVtYSBOYWNpb25hbCBkZSBDZXJ0aWZpY2FjaW9uIEVsZWN0cm9u +aWNhMQswCQYDVQQGEwJWRTETMBEGA1UEAxMKUFNDUHJvY2VydDCCAiIwDQYJKoZI +hvcNAQEBBQADggIPADCCAgoCggIBANW39KOUM6FGqVVhSQ2oh3NekS1wwQYalNo9 +7BVCwfWMrmoX8Yqt/ICV6oNEolt6Vc5Pp6XVurgfoCfAUFM+jbnADrgV3NZs+J74 +BCXfgI8Qhd19L3uA3VcAZCP4bsm+lU/hdezgfl6VzbHvvnpC2Mks0+saGiKLt38G +ieU89RLAu9MLmV+QfI4tL3czkkohRqipCKzx9hEC2ZUWno0vluYC3XXCFCpa1sl9 +JcLB/KpnheLsvtF8PPqv1W7/U0HU9TI4seJfxPmOEO8GqQKJ/+MMbpfg353bIdD0 +PghpbNjU5Db4g7ayNo+c7zo3Fn2/omnXO1ty0K+qP1xmk6wKImG20qCZyFSTXai2 +0b1dCl53lKItwIKOvMoDKjSuc/HUtQy9vmebVOvh+qBa7Dh+PsHMosdEMXXqP+UH +0quhJZb25uSgXTcYOWEAM11G1ADEtMo88aKjPvM6/2kwLkDd9p+cJsmWN63nOaK/ +6mnbVSKVUyqUtd+tFjiBdWbjxywbk5yqjKPK2Ww8F22c3HxT4CAnQzb5EuE8XL1m +v6JpIzi4mWCZDlZTOpx+FIywBm/xhnaQr/2v/pDGj59/i5IjnOcVdo/Vi5QTcmn7 +K2FjiO/mpF7moxdqWEfLcU8UC17IAggmosvpr2uKGcfLFFb14dq12fy/czja+eev +bqQ34gcnAgMBAAGjggMXMIIDEzASBgNVHRMBAf8ECDAGAQH/AgEBMDcGA1UdEgQw +MC6CD3N1c2NlcnRlLmdvYi52ZaAbBgVghl4CAqASDBBSSUYtRy0yMDAwNDAzNi0w +MB0GA1UdDgQWBBRBDxk4qpl/Qguk1yeYVKIXTC1RVDCCAVAGA1UdIwSCAUcwggFD +gBStuyIdxuDSAaj9dlBSk+2YwU2u06GCASakggEiMIIBHjE+MDwGA1UEAxM1QXV0 +b3JpZGFkIGRlIENlcnRpZmljYWNpb24gUmFpeiBkZWwgRXN0YWRvIFZlbmV6b2xh +bm8xCzAJBgNVBAYTAlZFMRAwDgYDVQQHEwdDYXJhY2FzMRkwFwYDVQQIExBEaXN0 +cml0byBDYXBpdGFsMTYwNAYDVQQKEy1TaXN0ZW1hIE5hY2lvbmFsIGRlIENlcnRp +ZmljYWNpb24gRWxlY3Ryb25pY2ExQzBBBgNVBAsTOlN1cGVyaW50ZW5kZW5jaWEg +ZGUgU2VydmljaW9zIGRlIENlcnRpZmljYWNpb24gRWxlY3Ryb25pY2ExJTAjBgkq +hkiG9w0BCQEWFmFjcmFpekBzdXNjZXJ0ZS5nb2IudmWCAQowDgYDVR0PAQH/BAQD +AgEGME0GA1UdEQRGMESCDnByb2NlcnQubmV0LnZloBUGBWCGXgIBoAwMClBTQy0w +MDAwMDKgGwYFYIZeAgKgEgwQUklGLUotMzE2MzUzNzMtNzB2BgNVHR8EbzBtMEag +RKBChkBodHRwOi8vd3d3LnN1c2NlcnRlLmdvYi52ZS9sY3IvQ0VSVElGSUNBRE8t +UkFJWi1TSEEzODRDUkxERVIuY3JsMCOgIaAfhh1sZGFwOi8vYWNyYWl6LnN1c2Nl +cnRlLmdvYi52ZTA3BggrBgEFBQcBAQQrMCkwJwYIKwYBBQUHMAGGG2h0dHA6Ly9v +Y3NwLnN1c2NlcnRlLmdvYi52ZTBBBgNVHSAEOjA4MDYGBmCGXgMBAjAsMCoGCCsG +AQUFBwIBFh5odHRwOi8vd3d3LnN1c2NlcnRlLmdvYi52ZS9kcGMwDQYJKoZIhvcN +AQELBQADggIBACtZ6yKZu4SqT96QxtGGcSOeSwORR3C7wJJg7ODU523G0+1ng3dS +1fLld6c2suNUvtm7CpsR72H0xpkzmfWvADmNg7+mvTV+LFwxNG9s2/NkAZiqlCxB +3RWGymspThbASfzXg0gTB1GEMVKIu4YXx2sviiCtxQuPcD4quxtxj7mkoP3Yldmv +Wb8lK5jpY5MvYB7Eqvh39YtsL+1+LrVPQA3uvFd359m21D+VJzog1eWuq2w1n8Gh +HVnchIHuTQfiSLaeS5UtQbHh6N5+LwUeaO6/u5BlOsju6rEYNxxik6SgMexxbJHm +pHmJWhSnFFAFTKQAVzAswbVhltw+HoSvOULP5dAssSS830DD7X9jSr3hTxJkhpXz +sOfIt+FTvZLm8wyWuevo5pLtp4EJFAv8lXrPj9Y0TzYS3F7RNHXGRoAvlQSMx4bE +qCaJqD8Zm4G7UaRKhqsLEQ+xrmNTbSjq3TNWOByyrYDT13K9mmyZY+gAu0F2Bbdb +mRiKw7gSXFbPVgx96OLP7bx0R/vu0xdOIk9W/1DzLuY5poLWccret9W6aAjtmcz9 +opLLabid+Qqkpj5PkygqYWwHJgD/ll9ohri4zspV4KuxPX+Y1zMOWj3YeMLEYC/H +YvBhkdI4sPaeVdtAgAUSM84dkpvRabP/v/GSCmE1P93+hvS84Bpxs2Km +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIF0DCCBLigAwIBAgIEOrZQizANBgkqhkiG9w0BAQUFADB/MQswCQYDVQQGEwJC +TTEZMBcGA1UEChMQUXVvVmFkaXMgTGltaXRlZDElMCMGA1UECxMcUm9vdCBDZXJ0 +aWZpY2F0aW9uIEF1dGhvcml0eTEuMCwGA1UEAxMlUXVvVmFkaXMgUm9vdCBDZXJ0 +aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0wMTAzMTkxODMzMzNaFw0yMTAzMTcxODMz +MzNaMH8xCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBMaW1pdGVkMSUw +IwYDVQQLExxSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MS4wLAYDVQQDEyVR +dW9WYWRpcyBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIIBIjANBgkqhkiG +9w0BAQEFAAOCAQ8AMIIBCgKCAQEAv2G1lVO6V/z68mcLOhrfEYBklbTRvM16z/Yp +li4kVEAkOPcahdxYTMukJ0KX0J+DisPkBgNbAKVRHnAEdOLB1Dqr1607BxgFjv2D +rOpm2RgbaIr1VxqYuvXtdj182d6UajtLF8HVj71lODqV0D1VNk7feVcxKh7YWWVJ +WCCYfqtffp/p1k3sg3Spx2zY7ilKhSoGFPlU5tPaZQeLYzcS19Dsw3sgQUSj7cug +F+FxZc4dZjH3dgEZyH0DWLaVSR2mEiboxgx24ONmy+pdpibu5cxfvWenAScOospU +xbF6lR1xHkopigPcakXBpBlebzbNw6Kwt/5cOOJSvPhEQ+aQuwIDAQABo4ICUjCC +Ak4wPQYIKwYBBQUHAQEEMTAvMC0GCCsGAQUFBzABhiFodHRwczovL29jc3AucXVv +dmFkaXNvZmZzaG9yZS5jb20wDwYDVR0TAQH/BAUwAwEB/zCCARoGA1UdIASCAREw +ggENMIIBCQYJKwYBBAG+WAABMIH7MIHUBggrBgEFBQcCAjCBxxqBxFJlbGlhbmNl +IG9uIHRoZSBRdW9WYWRpcyBSb290IENlcnRpZmljYXRlIGJ5IGFueSBwYXJ0eSBh +c3N1bWVzIGFjY2VwdGFuY2Ugb2YgdGhlIHRoZW4gYXBwbGljYWJsZSBzdGFuZGFy +ZCB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB1c2UsIGNlcnRpZmljYXRpb24gcHJh +Y3RpY2VzLCBhbmQgdGhlIFF1b1ZhZGlzIENlcnRpZmljYXRlIFBvbGljeS4wIgYI +KwYBBQUHAgEWFmh0dHA6Ly93d3cucXVvdmFkaXMuYm0wHQYDVR0OBBYEFItLbe3T +KbkGGew5Oanwl4Rqy+/fMIGuBgNVHSMEgaYwgaOAFItLbe3TKbkGGew5Oanwl4Rq +y+/foYGEpIGBMH8xCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBMaW1p +dGVkMSUwIwYDVQQLExxSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MS4wLAYD +VQQDEyVRdW9WYWRpcyBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5ggQ6tlCL +MA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQUFAAOCAQEAitQUtf70mpKnGdSk +fnIYj9lofFIk3WdvOXrEql494liwTXCYhGHoG+NpGA7O+0dQoE7/8CQfvbLO9Sf8 +7C9TqnN7Az10buYWnuulLsS/VidQK2K6vkscPFVcQR0kvoIgR13VRH56FmjffU1R +cHhXHTMe/QKZnAzNCgVPx7uOpHX6Sm2xgI4JVrmcGmD+XcHXetwReNDWXcG31a0y +mQM6isxUJTkxgXsTIlG6Rmyhu576BGxJJnSP0nPrzDCi5upZIof4l/UO/erMkqQW +xFIY6iHOsfHmhIHluqmGKPJDWl0Snawe2ajlCmqnf6CHKc/yiU3U7MXi5nrQNiOK +SnQ2+Q== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFYDCCA0igAwIBAgIUeFhfLq0sGUvjNwc1NBMotZbUZZMwDQYJKoZIhvcNAQEL +BQAwSDELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxHjAc +BgNVBAMTFVF1b1ZhZGlzIFJvb3QgQ0EgMSBHMzAeFw0xMjAxMTIxNzI3NDRaFw00 +MjAxMTIxNzI3NDRaMEgxCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBM +aW1pdGVkMR4wHAYDVQQDExVRdW9WYWRpcyBSb290IENBIDEgRzMwggIiMA0GCSqG +SIb3DQEBAQUAA4ICDwAwggIKAoICAQCgvlAQjunybEC0BJyFuTHK3C3kEakEPBtV +wedYMB0ktMPvhd6MLOHBPd+C5k+tR4ds7FtJwUrVu4/sh6x/gpqG7D0DmVIB0jWe +rNrwU8lmPNSsAgHaJNM7qAJGr6Qc4/hzWHa39g6QDbXwz8z6+cZM5cOGMAqNF341 +68Xfuw6cwI2H44g4hWf6Pser4BOcBRiYz5P1sZK0/CPTz9XEJ0ngnjybCKOLXSoh +4Pw5qlPafX7PGglTvF0FBM+hSo+LdoINofjSxxR3W5A2B4GbPgb6Ul5jxaYA/qXp +UhtStZI5cgMJYr2wYBZupt0lwgNm3fME0UDiTouG9G/lg6AnhF4EwfWQvTA9xO+o +abw4m6SkltFi2mnAAZauy8RRNOoMqv8hjlmPSlzkYZqn0ukqeI1RPToV7qJZjqlc +3sX5kCLliEVx3ZGZbHqfPT2YfF72vhZooF6uCyP8Wg+qInYtyaEQHeTTRCOQiJ/G +KubX9ZqzWB4vMIkIG1SitZgj7Ah3HJVdYdHLiZxfokqRmu8hqkkWCKi9YSgxyXSt +hfbZxbGL0eUQMk1fiyA6PEkfM4VZDdvLCXVDaXP7a3F98N/ETH3Goy7IlXnLc6KO +Tk0k+17kBL5yG6YnLUlamXrXXAkgt3+UuU/xDRxeiEIbEbfnkduebPRq34wGmAOt +zCjvpUfzUwIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB +BjAdBgNVHQ4EFgQUo5fW816iEOGrRZ88F2Q87gFwnMwwDQYJKoZIhvcNAQELBQAD +ggIBABj6W3X8PnrHX3fHyt/PX8MSxEBd1DKquGrX1RUVRpgjpeaQWxiZTOOtQqOC +MTaIzen7xASWSIsBx40Bz1szBpZGZnQdT+3Btrm0DWHMY37XLneMlhwqI2hrhVd2 +cDMT/uFPpiN3GPoajOi9ZcnPP/TJF9zrx7zABC4tRi9pZsMbj/7sPtPKlL92CiUN +qXsCHKnQO18LwIE6PWThv6ctTr1NxNgpxiIY0MWscgKCP6o6ojoilzHdCGPDdRS5 +YCgtW2jgFqlmgiNR9etT2DGbe+m3nUvriBbP+V04ikkwj+3x6xn0dxoxGE1nVGwv +b2X52z3sIexe9PSLymBlVNFxZPT5pqOBMzYzcfCkeF9OrYMh3jRJjehZrJ3ydlo2 +8hP0r+AJx2EqbPfgna67hkooby7utHnNkDPDs3b69fBsnQGQ+p6Q9pxyz0fawx/k +NSBT8lTR32GDpgLiJTjehTItXnOQUl1CxM49S+H5GYQd1aJQzEH7QRTDvdbJWqNj +ZgKAvQU6O0ec7AAmTPWIUb+oI38YB7AL7YsmoWTTYUrrXJ/es69nA7Mf3W1daWhp +q1467HxpvMc7hU6eFbm0FU/DlXpY18ls6Wy58yljXrQs8C097Vpl4KlbQMJImYFt +nh8GKjwStIsPm6Ik8KaN1nrgS7ZklmOVhMJKzRwuJIczYOXD +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFtzCCA5+gAwIBAgICBQkwDQYJKoZIhvcNAQEFBQAwRTELMAkGA1UEBhMCQk0x +GTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxGzAZBgNVBAMTElF1b1ZhZGlzIFJv +b3QgQ0EgMjAeFw0wNjExMjQxODI3MDBaFw0zMTExMjQxODIzMzNaMEUxCzAJBgNV +BAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBMaW1pdGVkMRswGQYDVQQDExJRdW9W +YWRpcyBSb290IENBIDIwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCa +GMpLlA0ALa8DKYrwD4HIrkwZhR0In6spRIXzL4GtMh6QRr+jhiYaHv5+HBg6XJxg +Fyo6dIMzMH1hVBHL7avg5tKifvVrbxi3Cgst/ek+7wrGsxDp3MJGF/hd/aTa/55J +WpzmM+Yklvc/ulsrHHo1wtZn/qtmUIttKGAr79dgw8eTvI02kfN/+NsRE8Scd3bB +rrcCaoF6qUWD4gXmuVbBlDePSHFjIuwXZQeVikvfj8ZaCuWw419eaxGrDPmF60Tp ++ARz8un+XJiM9XOva7R+zdRcAitMOeGylZUtQofX1bOQQ7dsE/He3fbE+Ik/0XX1 +ksOR1YqI0JDs3G3eicJlcZaLDQP9nL9bFqyS2+r+eXyt66/3FsvbzSUr5R/7mp/i +Ucw6UwxI5g69ybR2BlLmEROFcmMDBOAENisgGQLodKcftslWZvB1JdxnwQ5hYIiz +PtGo/KPaHbDRsSNU30R2be1B2MGyIrZTHN81Hdyhdyox5C315eXbyOD/5YDXC2Og +/zOhD7osFRXql7PSorW+8oyWHhqPHWykYTe5hnMz15eWniN9gqRMgeKh0bpnX5UH +oycR7hYQe7xFSkyyBNKr79X9DFHOUGoIMfmR2gyPZFwDwzqLID9ujWc9Otb+fVuI +yV77zGHcizN300QyNQliBJIWENieJ0f7OyHj+OsdWwIDAQABo4GwMIGtMA8GA1Ud +EwEB/wQFMAMBAf8wCwYDVR0PBAQDAgEGMB0GA1UdDgQWBBQahGK8SEwzJQTU7tD2 +A8QZRtGUazBuBgNVHSMEZzBlgBQahGK8SEwzJQTU7tD2A8QZRtGUa6FJpEcwRTEL +MAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxGzAZBgNVBAMT +ElF1b1ZhZGlzIFJvb3QgQ0EgMoICBQkwDQYJKoZIhvcNAQEFBQADggIBAD4KFk2f +BluornFdLwUvZ+YTRYPENvbzwCYMDbVHZF34tHLJRqUDGCdViXh9duqWNIAXINzn +g/iN/Ae42l9NLmeyhP3ZRPx3UIHmfLTJDQtyU/h2BwdBR5YM++CCJpNVjP4iH2Bl +fF/nJrP3MpCYUNQ3cVX2kiF495V5+vgtJodmVjB3pjd4M1IQWK4/YY7yarHvGH5K +WWPKjaJW1acvvFYfzznB4vsKqBUsfU16Y8Zsl0Q80m/DShcK+JDSV6IZUaUtl0Ha +B0+pUNqQjZRG4T7wlP0QADj1O+hA4bRuVhogzG9Yje0uRY/W6ZM/57Es3zrWIozc +hLsib9D45MY56QSIPMO661V6bYCZJPVsAfv4l7CUW+v90m/xd2gNNWQjrLhVoQPR +TUIZ3Ph1WVaj+ahJefivDrkRoHy3au000LYmYjgahwz46P0u05B/B5EqHdZ+XIWD +mbA4CD/pXvk1B+TJYm5Xf6dQlfe6yJvmjqIBxdZmv3lh8zwc4bmCXF2gw+nYSL0Z +ohEUGW6yhhtoPkg3Goi3XZZenMfvJ2II4pEZXNLxId26F0KCl3GBUzGpn/Z9Yr9y +4aOTHcyKJloJONDO1w2AFrR4pTqHTI2KpdVGl/IsELm8VCLAAVBpQ570su9t+Oza +8eOx79+Rj1QqCyXBJhnEUhAFZdWCEOrCMc0u +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFYDCCA0igAwIBAgIURFc0JFuBiZs18s64KztbpybwdSgwDQYJKoZIhvcNAQEL +BQAwSDELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxHjAc +BgNVBAMTFVF1b1ZhZGlzIFJvb3QgQ0EgMiBHMzAeFw0xMjAxMTIxODU5MzJaFw00 +MjAxMTIxODU5MzJaMEgxCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBM +aW1pdGVkMR4wHAYDVQQDExVRdW9WYWRpcyBSb290IENBIDIgRzMwggIiMA0GCSqG +SIb3DQEBAQUAA4ICDwAwggIKAoICAQChriWyARjcV4g/Ruv5r+LrI3HimtFhZiFf +qq8nUeVuGxbULX1QsFN3vXg6YOJkApt8hpvWGo6t/x8Vf9WVHhLL5hSEBMHfNrMW +n4rjyduYNM7YMxcoRvynyfDStNVNCXJJ+fKH46nafaF9a7I6JaltUkSs+L5u+9ym +c5GQYaYDFCDy54ejiK2toIz/pgslUiXnFgHVy7g1gQyjO/Dh4fxaXc6AcW34Sas+ +O7q414AB+6XrW7PFXmAqMaCvN+ggOp+oMiwMzAkd056OXbxMmO7FGmh77FOm6RQ1 +o9/NgJ8MSPsc9PG/Srj61YxxSscfrf5BmrODXfKEVu+lV0POKa2Mq1W/xPtbAd0j +IaFYAI7D0GoT7RPjEiuA3GfmlbLNHiJuKvhB1PLKFAeNilUSxmn1uIZoL1NesNKq +IcGY5jDjZ1XHm26sGahVpkUG0CM62+tlXSoREfA7T8pt9DTEceT/AFr2XK4jYIVz +8eQQsSWu1ZK7E8EM4DnatDlXtas1qnIhO4M15zHfeiFuuDIIfR0ykRVKYnLP43eh +vNURG3YBZwjgQQvD6xVu+KQZ2aKrr+InUlYrAoosFCT5v0ICvybIxo/gbjh9Uy3l +7ZizlWNof/k19N+IxWA1ksB8aRxhlRbQ694Lrz4EEEVlWFA4r0jyWbYW8jwNkALG +cC4BrTwV1wIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB +BjAdBgNVHQ4EFgQU7edvdlq/YOxJW8ald7tyFnGbxD0wDQYJKoZIhvcNAQELBQAD +ggIBAJHfgD9DCX5xwvfrs4iP4VGyvD11+ShdyLyZm3tdquXK4Qr36LLTn91nMX66 +AarHakE7kNQIXLJgapDwyM4DYvmL7ftuKtwGTTwpD4kWilhMSA/ohGHqPHKmd+RC +roijQ1h5fq7KpVMNqT1wvSAZYaRsOPxDMuHBR//47PERIjKWnML2W2mWeyAMQ0Ga +W/ZZGYjeVYg3UQt4XAoeo0L9x52ID8DyeAIkVJOviYeIyUqAHerQbj5hLja7NQ4n +lv1mNDthcnPxFlxHBlRJAHpYErAK74X9sbgzdWqTHBLmYF5vHX/JHyPLhGGfHoJE ++V+tYlUkmlKY7VHnoX6XOuYvHxHaU4AshZ6rNRDbIl9qxV6XU/IyAgkwo1jwDQHV +csaxfGl7w/U2Rcxhbl5MlMVerugOXou/983g7aEOGzPuVBj+D77vfoRrQ+NwmNtd +dbINWQeFFSM51vHfqSYP1kjHs6Yi9TM3WpVHn3u6GBVv/9YUZINJ0gpnIdsPNWNg +KCLjsZWDzYWm3S8P52dSbrsvhXz1SnPnxT7AvSESBT/8twNJAlvIJebiVDj1eYeM +HVOyToV7BjjHLPj4sHKNJeV3UvQDHEimUF+IIDBu8oJDqz2XhOdT+yHBTw8imoa4 +WSr2Rz0ZiC3oheGe7IUIarFsNMkd7EgrO3jtZsSOeWmD3n+M +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIGnTCCBIWgAwIBAgICBcYwDQYJKoZIhvcNAQEFBQAwRTELMAkGA1UEBhMCQk0x +GTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxGzAZBgNVBAMTElF1b1ZhZGlzIFJv +b3QgQ0EgMzAeFw0wNjExMjQxOTExMjNaFw0zMTExMjQxOTA2NDRaMEUxCzAJBgNV +BAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBMaW1pdGVkMRswGQYDVQQDExJRdW9W +YWRpcyBSb290IENBIDMwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDM +V0IWVJzmmNPTTe7+7cefQzlKZbPoFog02w1ZkXTPkrgEQK0CSzGrvI2RaNggDhoB +4hp7Thdd4oq3P5kazethq8Jlph+3t723j/z9cI8LoGe+AaJZz3HmDyl2/7FWeUUr +H556VOijKTVopAFPD6QuN+8bv+OPEKhyq1hX51SGyMnzW9os2l2ObjyjPtr7guXd +8lyyBTNvijbO0BNO/79KDDRMpsMhvVAEVeuxu537RR5kFd5VAYwCdrXLoT9Cabwv +vWhDFlaJKjdhkf2mrk7AyxRllDdLkgbvBNDInIjbC3uBr7E9KsRlOni27tyAsdLT +mZw67mtaa7ONt9XOnMK+pUsvFrGeaDsGb659n/je7Mwpp5ijJUMv7/FfJuGITfhe +btfZFG4ZM2mnO4SJk8RTVROhUXhA+LjJou57ulJCg54U7QVSWllWp5f8nT8KKdjc +T5EOE7zelaTfi5m+rJsziO+1ga8bxiJTyPbH7pcUsMV8eFLI8M5ud2CEpukqdiDt +WAEXMJPpGovgc2PZapKUSU60rUqFxKMiMPwJ7Wgic6aIDFUhWMXhOp8q3crhkODZ +c6tsgLjoC2SToJyMGf+z0gzskSaHirOi4XCPLArlzW1oUevaPwV/izLmE1xr/l9A +4iLItLRkT9a6fUg+qGkM17uGcclzuD87nSVL2v9A6wIDAQABo4IBlTCCAZEwDwYD +VR0TAQH/BAUwAwEB/zCB4QYDVR0gBIHZMIHWMIHTBgkrBgEEAb5YAAMwgcUwgZMG +CCsGAQUFBwICMIGGGoGDQW55IHVzZSBvZiB0aGlzIENlcnRpZmljYXRlIGNvbnN0 +aXR1dGVzIGFjY2VwdGFuY2Ugb2YgdGhlIFF1b1ZhZGlzIFJvb3QgQ0EgMyBDZXJ0 +aWZpY2F0ZSBQb2xpY3kgLyBDZXJ0aWZpY2F0aW9uIFByYWN0aWNlIFN0YXRlbWVu +dC4wLQYIKwYBBQUHAgEWIWh0dHA6Ly93d3cucXVvdmFkaXNnbG9iYWwuY29tL2Nw +czALBgNVHQ8EBAMCAQYwHQYDVR0OBBYEFPLAE+CCQz777i9nMpY1XNu4ywLQMG4G +A1UdIwRnMGWAFPLAE+CCQz777i9nMpY1XNu4ywLQoUmkRzBFMQswCQYDVQQGEwJC +TTEZMBcGA1UEChMQUXVvVmFkaXMgTGltaXRlZDEbMBkGA1UEAxMSUXVvVmFkaXMg +Um9vdCBDQSAzggIFxjANBgkqhkiG9w0BAQUFAAOCAgEAT62gLEz6wPJv92ZVqyM0 +7ucp2sNbtrCD2dDQ4iH782CnO11gUyeim/YIIirnv6By5ZwkajGxkHon24QRiSem +d1o417+shvzuXYO8BsbRd2sPbSQvS3pspweWyuOEn62Iix2rFo1bZhfZFvSLgNLd ++LJ2w/w4E6oM3kJpK27zPOuAJ9v1pkQNn1pVWQvVDVJIxa6f8i+AxeoyUDUSly7B +4f/xI4hROJ/yZlZ25w9Rl6VSDE1JUZU2Pb+iSwwQHYaZTKrzchGT5Or2m9qoXadN +t54CrnMAyNojA+j56hl0YgCUyyIgvpSnWbWCar6ZeXqp8kokUvd0/bpO5qgdAm6x +DYBEwa7TIzdfu4V8K5Iu6H6li92Z4b8nby1dqnuH/grdS/yO9SbkbnBCbjPsMZ57 +k8HkyWkaPcBrTiJt7qtYTcbQQcEr6k8Sh17rRdhs9ZgC06DYVYoGmRmioHfRMJ6s +zHXug/WwYjnPbFfiTNKRCw51KBuav/0aQ/HKd/s7j2G4aSgWQgRecCocIdiP4b0j +Wy10QJLZYxkNc91pvGJHvOB0K7Lrfb5BG7XARsWhIstfTsEokt4YutUqKLsRixeT +mJlglFwjz1onl14LBQaTNx47aTbrqZ5hHY8y2o4M1nQ+ewkk2gF3R8Q7zTSMmfXK +4SVhM7JZG+Ju1zdXtg2pEto= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFYDCCA0igAwIBAgIULvWbAiin23r/1aOp7r0DoM8Sah0wDQYJKoZIhvcNAQEL +BQAwSDELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxHjAc +BgNVBAMTFVF1b1ZhZGlzIFJvb3QgQ0EgMyBHMzAeFw0xMjAxMTIyMDI2MzJaFw00 +MjAxMTIyMDI2MzJaMEgxCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBM +aW1pdGVkMR4wHAYDVQQDExVRdW9WYWRpcyBSb290IENBIDMgRzMwggIiMA0GCSqG +SIb3DQEBAQUAA4ICDwAwggIKAoICAQCzyw4QZ47qFJenMioKVjZ/aEzHs286IxSR +/xl/pcqs7rN2nXrpixurazHb+gtTTK/FpRp5PIpM/6zfJd5O2YIyC0TeytuMrKNu +FoM7pmRLMon7FhY4futD4tN0SsJiCnMK3UmzV9KwCoWdcTzeo8vAMvMBOSBDGzXR +U7Ox7sWTaYI+FrUoRqHe6okJ7UO4BUaKhvVZR74bbwEhELn9qdIoyhA5CcoTNs+c +ra1AdHkrAj80//ogaX3T7mH1urPnMNA3I4ZyYUUpSFlob3emLoG+B01vr87ERROR +FHAGjx+f+IdpsQ7vw4kZ6+ocYfx6bIrc1gMLnia6Et3UVDmrJqMz6nWB2i3ND0/k +A9HvFZcba5DFApCTZgIhsUfei5pKgLlVj7WiL8DWM2fafsSntARE60f75li59wzw +eyuxwHApw0BiLTtIadwjPEjrewl5qW3aqDCYz4ByA4imW0aucnl8CAMhZa634Ryl +sSqiMd5mBPfAdOhx3v89WcyWJhKLhZVXGqtrdQtEPREoPHtht+KPZ0/l7DxMYIBp +VzgeAVuNVejH38DMdyM0SXV89pgR6y3e7UEuFAUCf+D+IOs15xGsIs5XPd7JMG0Q +A4XN8f+MFrXBsj6IbGB/kE+V9/YtrQE5BwT6dYB9v0lQ7e/JxHwc64B+27bQ3RP+ +ydOc17KXqQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB +BjAdBgNVHQ4EFgQUxhfQvKjqAkPyGwaZXSuQILnXnOQwDQYJKoZIhvcNAQELBQAD +ggIBADRh2Va1EodVTd2jNTFGu6QHcrxfYWLopfsLN7E8trP6KZ1/AvWkyaiTt3px +KGmPc+FSkNrVvjrlt3ZqVoAh313m6Tqe5T72omnHKgqwGEfcIHB9UqM+WXzBusnI +FUBhynLWcKzSt/Ac5IYp8M7vaGPQtSCKFWGafoaYtMnCdvvMujAWzKNhxnQT5Wvv +oxXqA/4Ti2Tk08HS6IT7SdEQTXlm66r99I0xHnAUrdzeZxNMgRVhvLfZkXdxGYFg +u/BYpbWcC/ePIlUnwEsBbTuZDdQdm2NnL9DuDcpmvJRPpq3t/O5jrFc/ZSXPsoaP +0Aj/uHYUbt7lJ+yreLVTubY/6CD50qi+YUbKh4yE8/nxoGibIh6BJpsQBJFxwAYf +3KDTuVan45gtf4Od34wrnDKOMpTwATwiKp9Dwi7DmDkHOHv8XgBCH/MyJnmDhPbl +8MFREsALHgQjDFSlTC9JxUrRtm5gDWv8a4uFJGS3iQ6rJUdbPM9+Sb3H6QrG2vd+ +DhcI00iX0HGS8A85PjRqHH3Y8iKuu2n0M7SmSFXRDw4m6Oy2Cy2nhTXN/VnIn9HN +PlopNLk9hM6xZdRZkZFWdSHBd575euFgndOtBBj0fOtek49TSiIp+EgrPk2GrFt/ +ywaZWWDYWGWVjUTR939+J399roD1B0y2PpxxVJkES/1Y+Zj0 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIC5zCCAlACAQEwDQYJKoZIhvcNAQEFBQAwgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0 +IFZhbGlkYXRpb24gTmV0d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAz +BgNVBAsTLFZhbGlDZXJ0IENsYXNzIDMgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9y +aXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG +9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMB4XDTk5MDYyNjAwMjIzM1oXDTE5MDYy +NjAwMjIzM1owgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0IFZhbGlkYXRpb24gTmV0d29y +azEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENs +YXNzIDMgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9yaXR5MSEwHwYDVQQDExhodHRw +Oi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG9w0BCQEWEWluZm9AdmFsaWNl +cnQuY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDjmFGWHOjVsQaBalfD +cnWTq8+epvzzFlLWLU2fNUSoLgRNB0mKOCn1dzfnt6td3zZxFJmP3MKS8edgkpfs +2Ejcv8ECIMYkpChMMFp2bbFc893enhBxoYjHW5tBbcqwuI4V7q0zK89HBFx1cQqY +JJgpp0lZpd34t0NiYfPT4tBVPwIDAQABMA0GCSqGSIb3DQEBBQUAA4GBAFa7AliE +Zwgs3x/be0kz9dNnnfS0ChCzycUs4pJqcXgn8nCDQtM+z6lU9PHYkhaM0QTLS6vJ +n0WuPIqpsHEzXcjFV9+vqDWzf4mH6eglkrh/hXqu1rweN1gqZ8mRzyqBPu3GOd/A +PhmcGcwTTYJBtYze4D1gCCAPRX5ron+jjBXu +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDYTCCAkmgAwIBAgIQCgEBAQAAAnwAAAAKAAAAAjANBgkqhkiG9w0BAQUFADA6 +MRkwFwYDVQQKExBSU0EgU2VjdXJpdHkgSW5jMR0wGwYDVQQLExRSU0EgU2VjdXJp +dHkgMjA0OCBWMzAeFw0wMTAyMjIyMDM5MjNaFw0yNjAyMjIyMDM5MjNaMDoxGTAX +BgNVBAoTEFJTQSBTZWN1cml0eSBJbmMxHTAbBgNVBAsTFFJTQSBTZWN1cml0eSAy +MDQ4IFYzMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAt49VcdKA3Xtp +eafwGFAyPGJn9gqVB93mG/Oe2dJBVGutn3y+Gc37RqtBaB4Y6lXIL5F4iSj7Jylg +/9+PjDvJSZu1pJTOAeo+tWN7fyb9Gd3AIb2E0S1PRsNO3Ng3OTsor8udGuorryGl +wSMiuLgbWhOHV4PR8CDn6E8jQrAApX2J6elhc5SYcSa8LWrg903w8bYqODGBDSnh +AMFRD0xS+ARaqn1y07iHKrtjEAMqs6FPDVpeRrc9DvV07Jmf+T0kgYim3WBU6JU2 +PcYJk5qjEoAAVZkZR73QpXzDuvsf9/UP+Ky5tfQ3mBMY3oVbtwyCO4dvlTlYMNpu +AWgXIszACwIDAQABo2MwYTAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB +BjAfBgNVHSMEGDAWgBQHw1EwpKrpRa41JPr/JCwz0LGdjDAdBgNVHQ4EFgQUB8NR +MKSq6UWuNST6/yQsM9CxnYwwDQYJKoZIhvcNAQEFBQADggEBAF8+hnZuuDU8TjYc +HnmYv/3VEhF5Ug7uMYm83X/50cYVIeiKAVQNOvtUudZj1LGqlk2iQk3UUx+LEN5/ +Zb5gEydxiKRz44Rj0aRV4VCT5hsOedBnvEbIvz8XDZXmxpBp3ue0L96VfdASPz0+ +f00/FGj1EVDVwfSQpQgdMWD/YIwjVAqv/qFuxdF6Kmh4zx6CCiC0H63lhbJqaHVO +rSU3lIW+vaHU6rcMSzyd6BIA8F+sDeGscGNz9395nzIlQnQFgCi/vcEkllgVsRch +6YlL2weIZ/QVrXA+L02FO8K32/6YaCOJ4XQP3vTFhGMpG8zLB8kApKnXwiJPZ9d3 +7CAFYd4= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIGizCCBXOgAwIBAgIEO0XlaDANBgkqhkiG9w0BAQUFADBoMQswCQYDVQQGEwJF +UzEfMB0GA1UEChMWR2VuZXJhbGl0YXQgVmFsZW5jaWFuYTEPMA0GA1UECxMGUEtJ +R1ZBMScwJQYDVQQDEx5Sb290IENBIEdlbmVyYWxpdGF0IFZhbGVuY2lhbmEwHhcN +MDEwNzA2MTYyMjQ3WhcNMjEwNzAxMTUyMjQ3WjBoMQswCQYDVQQGEwJFUzEfMB0G +A1UEChMWR2VuZXJhbGl0YXQgVmFsZW5jaWFuYTEPMA0GA1UECxMGUEtJR1ZBMScw +JQYDVQQDEx5Sb290IENBIEdlbmVyYWxpdGF0IFZhbGVuY2lhbmEwggEiMA0GCSqG +SIb3DQEBAQUAA4IBDwAwggEKAoIBAQDGKqtXETcvIorKA3Qdyu0togu8M1JAJke+ +WmmmO3I2F0zo37i7L3bhQEZ0ZQKQUgi0/6iMweDHiVYQOTPvaLRfX9ptI6GJXiKj +SgbwJ/BXufjpTjJ3Cj9BZPPrZe52/lSqfR0grvPXdMIKX/UIKFIIzFVd0g/bmoGl +u6GzwZTNVOAydTGRGmKy3nXiz0+J2ZGQD0EbtFpKd71ng+CT516nDOeB0/RSrFOy +A8dEJvt55cs0YFAQexvba9dHq198aMpunUEDEO5rmXteJajCq+TA81yc477OMUxk +Hl6AovWDfgzWyoxVjr7gvkkHD6MkQXpYHYTqWBLI4bft75PelAgxAgMBAAGjggM7 +MIIDNzAyBggrBgEFBQcBAQQmMCQwIgYIKwYBBQUHMAGGFmh0dHA6Ly9vY3NwLnBr +aS5ndmEuZXMwEgYDVR0TAQH/BAgwBgEB/wIBAjCCAjQGA1UdIASCAiswggInMIIC +IwYKKwYBBAG/VQIBADCCAhMwggHoBggrBgEFBQcCAjCCAdoeggHWAEEAdQB0AG8A +cgBpAGQAYQBkACAAZABlACAAQwBlAHIAdABpAGYAaQBjAGEAYwBpAPMAbgAgAFIA +YQDtAHoAIABkAGUAIABsAGEAIABHAGUAbgBlAHIAYQBsAGkAdABhAHQAIABWAGEA +bABlAG4AYwBpAGEAbgBhAC4ADQAKAEwAYQAgAEQAZQBjAGwAYQByAGEAYwBpAPMA +bgAgAGQAZQAgAFAAcgDhAGMAdABpAGMAYQBzACAAZABlACAAQwBlAHIAdABpAGYA +aQBjAGEAYwBpAPMAbgAgAHEAdQBlACAAcgBpAGcAZQAgAGUAbAAgAGYAdQBuAGMA +aQBvAG4AYQBtAGkAZQBuAHQAbwAgAGQAZQAgAGwAYQAgAHAAcgBlAHMAZQBuAHQA +ZQAgAEEAdQB0AG8AcgBpAGQAYQBkACAAZABlACAAQwBlAHIAdABpAGYAaQBjAGEA +YwBpAPMAbgAgAHMAZQAgAGUAbgBjAHUAZQBuAHQAcgBhACAAZQBuACAAbABhACAA +ZABpAHIAZQBjAGMAaQDzAG4AIAB3AGUAYgAgAGgAdAB0AHAAOgAvAC8AdwB3AHcA +LgBwAGsAaQAuAGcAdgBhAC4AZQBzAC8AYwBwAHMwJQYIKwYBBQUHAgEWGWh0dHA6 +Ly93d3cucGtpLmd2YS5lcy9jcHMwHQYDVR0OBBYEFHs100DSHHgZZu90ECjcPk+y +eAT8MIGVBgNVHSMEgY0wgYqAFHs100DSHHgZZu90ECjcPk+yeAT8oWykajBoMQsw +CQYDVQQGEwJFUzEfMB0GA1UEChMWR2VuZXJhbGl0YXQgVmFsZW5jaWFuYTEPMA0G +A1UECxMGUEtJR1ZBMScwJQYDVQQDEx5Sb290IENBIEdlbmVyYWxpdGF0IFZhbGVu +Y2lhbmGCBDtF5WgwDQYJKoZIhvcNAQEFBQADggEBACRhTvW1yEICKrNcda3Fbcrn +lD+laJWIwVTAEGmiEi8YPyVQqHxK6sYJ2fR1xkDar1CdPaUWu20xxsdzCkj+IHLt +b8zog2EWRpABlUt9jppSCS/2bxzkoXHPjCpaF3ODR00PNvsETUlR4hTJZGH71BTg +9J63NI8KJr2XXPR5OkowGcytT6CYirQxlyric21+eLj4iIlPsSKRZEv1UN4D2+XF +ducTZnV+ZfsBn5OHiJ35Rld8TWCvmHMTI6QgkYH60GFmuH3Rr9ZvHmw96RH9qfmC +IoaZM3Fa6hlXPZHNqcCjbgcTpsnt+GijnsNacgmHKNHEc8RzGF9QdRYxn7fofMM= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDbTCCAlWgAwIBAgIBATANBgkqhkiG9w0BAQUFADBYMQswCQYDVQQGEwJKUDEr +MCkGA1UEChMiSmFwYW4gQ2VydGlmaWNhdGlvbiBTZXJ2aWNlcywgSW5jLjEcMBoG +A1UEAxMTU2VjdXJlU2lnbiBSb290Q0ExMTAeFw0wOTA0MDgwNDU2NDdaFw0yOTA0 +MDgwNDU2NDdaMFgxCzAJBgNVBAYTAkpQMSswKQYDVQQKEyJKYXBhbiBDZXJ0aWZp +Y2F0aW9uIFNlcnZpY2VzLCBJbmMuMRwwGgYDVQQDExNTZWN1cmVTaWduIFJvb3RD +QTExMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA/XeqpRyQBTvLTJsz +i1oURaTnkBbR31fSIRCkF/3frNYfp+TbfPfs37gD2pRY/V1yfIw/XwFndBWW4wI8 +h9uuywGOwvNmxoVF9ALGOrVisq/6nL+k5tSAMJjzDbaTj6nU2DbysPyKyiyhFTOV +MdrAG/LuYpmGYz+/3ZMqg6h2uRMft85OQoWPIucuGvKVCbIFtUROd6EgvanyTgp9 +UK31BQ1FT0Zx/Sg+U/sE2C3XZR1KG/rPO7AxmjVuyIsG0wCR8pQIZUyxNAYAeoni +8McDWc/V1uinMrPmmECGxc0nEovMe863ETxiYAcjPitAbpSACW22s293bzUIUPsC +h8U+iQIDAQABo0IwQDAdBgNVHQ4EFgQUW/hNT7KlhtQ60vFjmqC+CfZXt94wDgYD +VR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEFBQADggEB +AKChOBZmLqdWHyGcBvod7bkixTgm2E5P7KN/ed5GIaGHd48HCJqypMWvDzKYC3xm +KbabfSVSSUOrTC4rbnpwrxYO4wJs+0LmGJ1F2FXI6Dvd5+H0LgscNFxsWEr7jIhQ +X5Ucv+2rIrVls4W6ng+4reV6G4pQOh29Dbx7VFALuUKvVaAYga1lme++5Jy/xIWr +QbJUb9wlze144o4MjQlJ3WN7WmmWAiGovVJZ6X01y8hSyn+B/tlr0/cR7SXf+Of5 +pPpyl4RTDaXQMhhRdlkUbA/r7F+AjHVDg8OFmP9Mni0N5HeDk061lgeLKBObjBmN +QSdJQO7e5iNEOdyhIta6A/I= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDuDCCAqCgAwIBAgIQDPCOXAgWpa1Cf/DrJxhZ0DANBgkqhkiG9w0BAQUFADBI +MQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3QgQ29ycG9yYXRpb24x +FzAVBgNVBAMTDlNlY3VyZVRydXN0IENBMB4XDTA2MTEwNzE5MzExOFoXDTI5MTIz +MTE5NDA1NVowSDELMAkGA1UEBhMCVVMxIDAeBgNVBAoTF1NlY3VyZVRydXN0IENv +cnBvcmF0aW9uMRcwFQYDVQQDEw5TZWN1cmVUcnVzdCBDQTCCASIwDQYJKoZIhvcN +AQEBBQADggEPADCCAQoCggEBAKukgeWVzfX2FI7CT8rU4niVWJxB4Q2ZQCQXOZEz +Zum+4YOvYlyJ0fwkW2Gz4BERQRwdbvC4u/jep4G6pkjGnx29vo6pQT64lO0pGtSO +0gMdA+9tDWccV9cGrcrI9f4Or2YlSASWC12juhbDCE/RRvgUXPLIXgGZbf2IzIao +wW8xQmxSPmjL8xk037uHGFaAJsTQ3MBv396gwpEWoGQRS0S8Hvbn+mPeZqx2pHGj +7DaUaHp3pLHnDi+BeuK1cobvomuL8A/b01k/unK8RCSc43Oz969XL0Imnal0ugBS +8kvNU3xHCzaFDmapCJcWNFfBZveA4+1wVMeT4C4oFVmHursCAwEAAaOBnTCBmjAT +BgkrBgEEAYI3FAIEBh4EAEMAQTALBgNVHQ8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB +/zAdBgNVHQ4EFgQUQjK2FvoE/f5dS3rD/fdMQB1aQ68wNAYDVR0fBC0wKzApoCeg +JYYjaHR0cDovL2NybC5zZWN1cmV0cnVzdC5jb20vU1RDQS5jcmwwEAYJKwYBBAGC +NxUBBAMCAQAwDQYJKoZIhvcNAQEFBQADggEBADDtT0rhWDpSclu1pqNlGKa7UTt3 +6Z3q059c4EVlew3KW+JwULKUBRSuSceNQQcSc5R+DCMh/bwQf2AQWnL1mA6s7Ll/ +3XpvXdMc9P+IBWlCqQVxyLesJugutIxq/3HcuLHfmbx8IVQr5Fiiu1cprp6poxkm +D5kuCLDv/WnPmRoJjeOnnyvJNjR7JLN4TJUXpAYmHrZkUjZfYGfZnMUFdAvnZyPS +CPyI6a6Lf+Ew9Dd+/cYy2i2eRDAwbO4H3tI0/NL/QPZL9GZGBlSm8jIKYyYwa5vR +3ItHuuG51WLQoqD0ZwV4KWMabwTW+MZMo5qxN7SN5ShLHZ4swrhovO0C7jE= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDvDCCAqSgAwIBAgIQB1YipOjUiolN9BPI8PjqpTANBgkqhkiG9w0BAQUFADBK +MQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3QgQ29ycG9yYXRpb24x +GTAXBgNVBAMTEFNlY3VyZSBHbG9iYWwgQ0EwHhcNMDYxMTA3MTk0MjI4WhcNMjkx +MjMxMTk1MjA2WjBKMQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3Qg +Q29ycG9yYXRpb24xGTAXBgNVBAMTEFNlY3VyZSBHbG9iYWwgQ0EwggEiMA0GCSqG +SIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvNS7YrGxVaQZx5RNoJLNP2MwhR/jxYDiJ +iQPpvepeRlMJ3Fz1Wuj3RSoC6zFh1ykzTM7HfAo3fg+6MpjhHZevj8fcyTiW89sa +/FHtaMbQbqR8JNGuQsiWUGMu4P51/pinX0kuleM5M2SOHqRfkNJnPLLZ/kG5VacJ +jnIFHovdRIWCQtBJwB1g8NEXLJXr9qXBkqPFwqcIYA1gBBCWeZ4WNOaptvolRTnI +HmX5k/Wq8VLcmZg9pYYaDDUz+kulBAYVHDGA76oYa8J719rO+TMg1fW9ajMtgQT7 +sFzUnKPiXB3jqUJ1XnvUd+85VLrJChgbEplJL4hL/VBi0XPnj3pDAgMBAAGjgZ0w +gZowEwYJKwYBBAGCNxQCBAYeBABDAEEwCwYDVR0PBAQDAgGGMA8GA1UdEwEB/wQF +MAMBAf8wHQYDVR0OBBYEFK9EBMJBfkiD2045AuzshHrmzsmkMDQGA1UdHwQtMCsw +KaAnoCWGI2h0dHA6Ly9jcmwuc2VjdXJldHJ1c3QuY29tL1NHQ0EuY3JsMBAGCSsG +AQQBgjcVAQQDAgEAMA0GCSqGSIb3DQEBBQUAA4IBAQBjGghAfaReUw132HquHw0L +URYD7xh8yOOvaliTFGCRsoTciE6+OYo68+aCiV0BN7OrJKQVDpI1WkpEXk5X+nXO +H0jOZvQ8QCaSmGwb7iRGDBezUqXbpZGRzzfTb+cnCDpOGR86p1hcF895P4vkp9Mm +I50mD1hp/Ed+stCNi5O/KU9DaXR2Z0vPB4zmAve14bRDtUstFJ/53CYNv6ZHdAbY +iNE6KTCEztI5gGIbqMdXSbxqVVFnFUq+NQfk1XWYN3kwFNspnWzFacxHVaIw98xc +f8LDmBxrThaA63p4ZUWiABqvDA1VZDRIuJK58bRQKfJPIx/abKwfROHdI3hRW8cW +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDfTCCAmWgAwIBAgIBADANBgkqhkiG9w0BAQUFADBgMQswCQYDVQQGEwJKUDEl +MCMGA1UEChMcU0VDT00gVHJ1c3QgU3lzdGVtcyBDTy4sTFRELjEqMCgGA1UECxMh +U2VjdXJpdHkgQ29tbXVuaWNhdGlvbiBFViBSb290Q0ExMB4XDTA3MDYwNjAyMTIz +MloXDTM3MDYwNjAyMTIzMlowYDELMAkGA1UEBhMCSlAxJTAjBgNVBAoTHFNFQ09N +IFRydXN0IFN5c3RlbXMgQ08uLExURC4xKjAoBgNVBAsTIVNlY3VyaXR5IENvbW11 +bmljYXRpb24gRVYgUm9vdENBMTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC +ggEBALx/7FebJOD+nLpCeamIivqA4PUHKUPqjgo0No0c+qe1OXj/l3X3L+SqawSE +RMqm4miO/VVQYg+kcQ7OBzgtQoVQrTyWb4vVog7P3kmJPdZkLjjlHmy1V4qe70gO +zXppFodEtZDkBp2uoQSXWHnvIEqCa4wiv+wfD+mEce3xDuS4GBPMVjZd0ZoeUWs5 +bmB2iDQL87PRsJ3KYeJkHcFGB7hj3R4zZbOOCVVSPbW9/wfrrWFVGCypaZhKqkDF +MxRldAD5kd6vA0jFQFTcD4SQaCDFkpbcLuUCRarAX1T4bepJz11sS6/vmsJWXMY1 +VkJqMF/Cq/biPT+zyRGPMUzXn0kCAwEAAaNCMEAwHQYDVR0OBBYEFDVK9U2vP9eC +OKyrcWUXdYydVZPmMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MA0G +CSqGSIb3DQEBBQUAA4IBAQCoh+ns+EBnXcPBZsdAS5f8hxOQWsTvoMpfi7ent/HW +tWS3irO4G8za+6xmiEHO6Pzk2x6Ipu0nUBsCMCRGef4Eh3CXQHPRwMFXGZpppSeZ +q51ihPZRwSzJIxXYKLerJRO1RuGGAv8mjMSIkh1W/hln8lXkgKNrnKt34VFxDSDb +EJrbvXZ5B3eZKK2aXtqxT0QsNY6llsf9g/BYxnnWmHyojf6GPgcWkuF75x3sM3Z+ +Qi5KhfmRiWiEA4Glm5q+4zfFVKtWOxgtQaQM+ELbmaDgcm+7XeEWT1MKZPlO9L9O +VL14bIjqv5wTJMJwaaJ/D8g8rQjJsJhAoyrniIPtd490 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDdzCCAl+gAwIBAgIBADANBgkqhkiG9w0BAQsFADBdMQswCQYDVQQGEwJKUDEl +MCMGA1UEChMcU0VDT00gVHJ1c3QgU3lzdGVtcyBDTy4sTFRELjEnMCUGA1UECxMe +U2VjdXJpdHkgQ29tbXVuaWNhdGlvbiBSb290Q0EyMB4XDTA5MDUyOTA1MDAzOVoX +DTI5MDUyOTA1MDAzOVowXTELMAkGA1UEBhMCSlAxJTAjBgNVBAoTHFNFQ09NIFRy +dXN0IFN5c3RlbXMgQ08uLExURC4xJzAlBgNVBAsTHlNlY3VyaXR5IENvbW11bmlj +YXRpb24gUm9vdENBMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANAV +OVKxUrO6xVmCxF1SrjpDZYBLx/KWvNs2l9amZIyoXvDjChz335c9S672XewhtUGr +zbl+dp+++T42NKA7wfYxEUV0kz1XgMX5iZnK5atq1LXaQZAQwdbWQonCv/Q4EpVM +VAX3NuRFg3sUZdbcDE3R3n4MqzvEFb46VqZab3ZpUql6ucjrappdUtAtCms1FgkQ +hNBqyjoGADdH5H5XTz+L62e4iKrFvlNVspHEfbmwhRkGeC7bYRr6hfVKkaHnFtWO +ojnflLhwHyg/i/xAXmODPIMqGplrz95Zajv8bxbXH/1KEOtOghY6rCcMU/Gt1SSw +awNQwS08Ft1ENCcadfsCAwEAAaNCMEAwHQYDVR0OBBYEFAqFqXdlBZh8QIH4D5cs +OPEK7DzPMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3 +DQEBCwUAA4IBAQBMOqNErLlFsceTfsgLCkLfZOoc7llsCLqJX2rKSpWeeo8HxdpF +coJxDjrSzG+ntKEju/Ykn8sX/oymzsLS28yN/HH8AynBbF0zX2S2ZTuJbxh2ePXc +okgfGT+Ok+vx+hfuzU7jBBJV1uXk3fs+BXziHV7Gp7yXT2g69ekuCkO2r1dcYmh8 +t/2jioSgrGK+KwmHNPBqAbubKVY8/gA3zyNs8U6qtnRGEmyR7jTV7JqR50S+kDFy +1UkC9gLl9B/rfNmWVan/7Ir5mUf/NVoCqgTLiluHcSmRvaS0eg29mvVXIwAHIRc/ +SjnRBUkLp7Y3gaVdjKozXoEofKd9J+sAro03 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDWjCCAkKgAwIBAgIBADANBgkqhkiG9w0BAQUFADBQMQswCQYDVQQGEwJKUDEY +MBYGA1UEChMPU0VDT00gVHJ1c3QubmV0MScwJQYDVQQLEx5TZWN1cml0eSBDb21t +dW5pY2F0aW9uIFJvb3RDQTEwHhcNMDMwOTMwMDQyMDQ5WhcNMjMwOTMwMDQyMDQ5 +WjBQMQswCQYDVQQGEwJKUDEYMBYGA1UEChMPU0VDT00gVHJ1c3QubmV0MScwJQYD +VQQLEx5TZWN1cml0eSBDb21tdW5pY2F0aW9uIFJvb3RDQTEwggEiMA0GCSqGSIb3 +DQEBAQUAA4IBDwAwggEKAoIBAQCzs/5/022x7xZ8V6UMbXaKL0u/ZPtM7orw8yl8 +9f/uKuDp6bpbZCKamm8sOiZpUQWZJtzVHGpxxpp9Hp3dfGzGjGdnSj74cbAZJ6kJ +DKaVv0uMDPpVmDvY6CKhS3E4eayXkmmziX7qIWgGmBSWh9JhNrxtJ1aeV+7AwFb9 +Ms+k2Y7CI9eNqPPYJayX5HA49LY6tJ07lyZDo6G8SVlyTCMwhwFY9k6+HGhWZq/N +QV3Is00qVUarH9oe4kA92819uZKAnDfdDJZkndwi92SL32HeFZRSFaB9UslLqCHJ +xrHty8OVYNEP8Ktw+N/LTX7s1vqr2b1/VPKl6Xn62dZ2JChzAgMBAAGjPzA9MB0G +A1UdDgQWBBSgc0mZaNyFW2XjmygvV5+9M7wHSDALBgNVHQ8EBAMCAQYwDwYDVR0T +AQH/BAUwAwEB/zANBgkqhkiG9w0BAQUFAAOCAQEAaECpqLvkT115swW1F7NgE+vG +kl3g0dNq/vu+m22/xwVtWSDEHPC32oRYAmP6SBbvT6UL90qY8j+eG61Ha2POCEfr +Uj94nK9NrvjVT8+amCoQQTlSxN3Zmw7vkwGusi7KaEIkQmywszo+zenaSMQVy+n5 +Bw+SUEmK3TGXX8npN6o7WWWXlDLJs58+OmJYxUmtYg5xpTKqL8aJdkNAExNnPaJU +JRDL8Try2frbSVa7pv6nQTXD4IhhyYjH3zYQIphZ6rBK+1YWc26sTfcioU+tHXot +RSflMMFe8toTyyVCUZVHA4xsIcx0Qu1T/zOLjw9XARYvz6buyXAiFL39vmwLAw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDIDCCAgigAwIBAgIBHTANBgkqhkiG9w0BAQUFADA5MQswCQYDVQQGEwJGSTEP +MA0GA1UEChMGU29uZXJhMRkwFwYDVQQDExBTb25lcmEgQ2xhc3MyIENBMB4XDTAx +MDQwNjA3Mjk0MFoXDTIxMDQwNjA3Mjk0MFowOTELMAkGA1UEBhMCRkkxDzANBgNV +BAoTBlNvbmVyYTEZMBcGA1UEAxMQU29uZXJhIENsYXNzMiBDQTCCASIwDQYJKoZI +hvcNAQEBBQADggEPADCCAQoCggEBAJAXSjWdyvANlsdE+hY3/Ei9vX+ALTU74W+o +Z6m/AxxNjG8yR9VBaKQTBME1DJqEQ/xcHf+Js+gXGM2RX/uJ4+q/Tl18GybTdXnt +5oTjV+WtKcT0OijnpXuENmmz/V52vaMtmdOQTiMofRhj8VQ7Jp12W5dCsv+u8E7s +3TmVToMGf+dJQMjFAbJUWmYdPfz56TwKnoG4cPABi+QjVHzIrviQHgCWctRUz2Ej +vOr7nQKV0ba5cTppCD8PtOFCx4j1P5iop7oc4HFx71hXgVB6XGt0Rg6DA5jDjqhu +8nYybieDwnPz3BjotJPqdURrBGAgcVeHnfO+oJAjPYok4doh28MCAwEAAaMzMDEw +DwYDVR0TAQH/BAUwAwEB/zARBgNVHQ4ECgQISqCqWITTXjwwCwYDVR0PBAQDAgEG +MA0GCSqGSIb3DQEBBQUAA4IBAQBazof5FnIVV0sd2ZvnoiYw7JNn39Yt0jSv9zil +zqsWuasvfDXLrNAPtEwr/IDva4yRXzZ299uzGxnq9LIR/WFxRL8oszodv7ND6J+/ +3DEIcbCdjdY0RzKQxmUk96BKfARzjzlvF4xytb1LyHr4e4PDKE6cCepnP7JnBBvD +FNr450kkkdAdavphOe9r5yF1BgfYErQhIHBCcYHaPJo2vqZbDWpsmh+Re/n570K6 +Tk6ezAyNlNzZRZxe7EJQY670XcSxEtzKO6gunRRaBXW37Ndj4ro1tgQIkejanZz2 +ZrUYrAqmVCY0M9IbwdR/GjqOC6oybtv8TyWf2TLHllpwrN9M +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFcDCCA1igAwIBAgIEAJiWjTANBgkqhkiG9w0BAQsFADBYMQswCQYDVQQGEwJO +TDEeMBwGA1UECgwVU3RhYXQgZGVyIE5lZGVybGFuZGVuMSkwJwYDVQQDDCBTdGFh +dCBkZXIgTmVkZXJsYW5kZW4gRVYgUm9vdCBDQTAeFw0xMDEyMDgxMTE5MjlaFw0y +MjEyMDgxMTEwMjhaMFgxCzAJBgNVBAYTAk5MMR4wHAYDVQQKDBVTdGFhdCBkZXIg +TmVkZXJsYW5kZW4xKTAnBgNVBAMMIFN0YWF0IGRlciBOZWRlcmxhbmRlbiBFViBS +b290IENBMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA48d+ifkkSzrS +M4M1LGns3Amk41GoJSt5uAg94JG6hIXGhaTK5skuU6TJJB79VWZxXSzFYGgEt9nC +UiY4iKTWO0Cmws0/zZiTs1QUWJZV1VD+hq2kY39ch/aO5ieSZxeSAgMs3NZmdO3d +Z//BYY1jTw+bbRcwJu+r0h8QoPnFfxZpgQNH7R5ojXKhTbImxrpsX23Wr9GxE46p +rfNeaXUmGD5BKyF/7otdBwadQ8QpCiv8Kj6GyzyDOvnJDdrFmeK8eEEzduG/L13l +pJhQDBXd4Pqcfzho0LKmeqfRMb1+ilgnQ7O6M5HTp5gVXJrm0w912fxBmJc+qiXb +j5IusHsMX/FjqTf5m3VpTCgmJdrV8hJwRVXj33NeN/UhbJCONVrJ0yPr08C+eKxC +KFhmpUZtcALXEPlLVPxdhkqHz3/KRawRWrUgUY0viEeXOcDPusBCAUCZSCELa6fS +/ZbV0b5GnUngC6agIk440ME8MLxwjyx1zNDFjFE7PZQIZCZhfbnDZY8UnCHQqv0X +cgOPvZuM5l5Tnrmd74K74bzickFbIZTTRTeU0d8JOV3nI6qaHcptqAqGhYqCvkIH +1vI4gnPah1vlPNOePqc7nvQDs/nxfRN0Av+7oeX6AHkcpmZBiFxgV6YuCcS6/ZrP +px9Aw7vMWgpVSzs4dlG4Y4uElBbmVvMCAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB +/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFP6rAJCYniT8qcwaivsnuL8wbqg7 +MA0GCSqGSIb3DQEBCwUAA4ICAQDPdyxuVr5Os7aEAJSrR8kN0nbHhp8dB9O2tLsI +eK9p0gtJ3jPFrK3CiAJ9Brc1AsFgyb/E6JTe1NOpEyVa/m6irn0F3H3zbPB+po3u +2dfOWBfoqSmuc0iH55vKbimhZF8ZE/euBhD/UcabTVUlT5OZEAFTdfETzsemQUHS +v4ilf0X8rLiltTMMgsT7B/Zq5SWEXwbKwYY5EdtYzXc7LMJMD16a4/CrPmEbUCTC +wPTxGfARKbalGAKb12NMcIxHowNDXLldRqANb/9Zjr7dn3LDWyvfjFvO5QxGbJKy +CqNMVEIYFRIYvdr8unRu/8G2oGTYqV9Vrp9canaW2HNnh/tNf1zuacpzEPuKqf2e +vTY4SUmH9A4U8OmHuD+nT3pajnnUk+S7aFKErGzp85hwVXIy+TSrK0m1zSBi5Dp6 +Z2Orltxtrpfs/J92VoguZs9btsmksNcFuuEnL5O7Jiqik7Ab846+HUCjuTaPPoIa +Gl6I6lD4WeKDRikL40Rc4ZW2aZCaFG+XroHPaO+Zmr615+F/+PoTRxZMzG0IQOeL +eG9QgkRQP2YGiqtDhFZKDyAthg710tvSeopLzaXoTvFeJiUBWSOgftL2fiFX1ye8 +FVdMpEbB4IMeDExNH08GGeL5qPQ6gqGyeUN51q1veieQA6TqJIc/2b3Z6fJfUEkc +7uzXLg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDujCCAqKgAwIBAgIEAJiWijANBgkqhkiG9w0BAQUFADBVMQswCQYDVQQGEwJO +TDEeMBwGA1UEChMVU3RhYXQgZGVyIE5lZGVybGFuZGVuMSYwJAYDVQQDEx1TdGFh +dCBkZXIgTmVkZXJsYW5kZW4gUm9vdCBDQTAeFw0wMjEyMTcwOTIzNDlaFw0xNTEy +MTYwOTE1MzhaMFUxCzAJBgNVBAYTAk5MMR4wHAYDVQQKExVTdGFhdCBkZXIgTmVk +ZXJsYW5kZW4xJjAkBgNVBAMTHVN0YWF0IGRlciBOZWRlcmxhbmRlbiBSb290IENB +MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAmNK1URF6gaYUmHFtvszn +ExvWJw56s2oYHLZhWtVhCb/ekBPHZ+7d89rFDBKeNVU+LCeIQGv33N0iYfXCxw71 +9tV2U02PjLwYdjeFnejKScfST5gTCaI+Ioicf9byEGW07l8Y1Rfj+MX94p2i71MO +hXeiD+EwR+4A5zN9RGcaC1Hoi6CeUJhoNFIfLm0B8mBF8jHrqTFoKbt6QZ7GGX+U +tFE5A3+y3qcym7RHjm+0Sq7lr7HcsBthvJly3uSJt3omXdozSVtSnA71iq3DuD3o +BmrC1SoLbHuEvVYFy4ZlkuxEK7COudxwC0barbxjiDn622r+I/q85Ej0ZytqERAh +SQIDAQABo4GRMIGOMAwGA1UdEwQFMAMBAf8wTwYDVR0gBEgwRjBEBgRVHSAAMDww +OgYIKwYBBQUHAgEWLmh0dHA6Ly93d3cucGtpb3ZlcmhlaWQubmwvcG9saWNpZXMv +cm9vdC1wb2xpY3kwDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBSofeu8Y6R0E3QA +7Jbg0zTBLL9s+DANBgkqhkiG9w0BAQUFAAOCAQEABYSHVXQ2YcG70dTGFagTtJ+k +/rvuFbQvBgwp8qiSpGEN/KtcCFtREytNwiphyPgJWPwtArI5fZlmgb9uXJVFIGzm +eafR2Bwp/MIgJ1HI8XxdNGdphREwxgDS1/PTfLbwMVcoEoJz6TMvplW0C5GUR5z6 +u3pCMuiufi3IvKwUv9kP2Vv8wfl6leF9fpb8cbDCTMjfRTTJzg3ynGQI0DvDKcWy +7ZAEwbEpkcUwb8GpcjPM/l0WFywRaed+/sWDCN+83CI6LiBpIzlWYGeQiy52OfsR +iJf2fL1LuCAWZwWN4jvBcj+UlTfHXbme2JOhF4//DGYVwSR8MnwDHTuhWEUykw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFyjCCA7KgAwIBAgIEAJiWjDANBgkqhkiG9w0BAQsFADBaMQswCQYDVQQGEwJO +TDEeMBwGA1UECgwVU3RhYXQgZGVyIE5lZGVybGFuZGVuMSswKQYDVQQDDCJTdGFh +dCBkZXIgTmVkZXJsYW5kZW4gUm9vdCBDQSAtIEcyMB4XDTA4MDMyNjExMTgxN1oX +DTIwMDMyNTExMDMxMFowWjELMAkGA1UEBhMCTkwxHjAcBgNVBAoMFVN0YWF0IGRl +ciBOZWRlcmxhbmRlbjErMCkGA1UEAwwiU3RhYXQgZGVyIE5lZGVybGFuZGVuIFJv +b3QgQ0EgLSBHMjCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMVZ5291 +qj5LnLW4rJ4L5PnZyqtdj7U5EILXr1HgO+EASGrP2uEGQxGZqhQlEq0i6ABtQ8Sp +uOUfiUtnvWFI7/3S4GCI5bkYYCjDdyutsDeqN95kWSpGV+RLufg3fNU254DBtvPU +Z5uW6M7XxgpT0GtJlvOjCwV3SPcl5XCsMBQgJeN/dVrlSPhOewMHBPqCYYdu8DvE +pMfQ9XQ+pV0aCPKbJdL2rAQmPlU6Yiile7Iwr/g3wtG61jj99O9JMDeZJiFIhQGp +5Rbn3JBV3w/oOM2ZNyFPXfUib2rFEhZgF1XyZWampzCROME4HYYEhLoaJXhena/M +UGDWE4dS7WMfbWV9whUYdMrhfmQpjHLYFhN9C0lK8SgbIHRrxT3dsKpICT0ugpTN +GmXZK4iambwYfp/ufWZ8Pr2UuIHOzZgweMFvZ9C+X+Bo7d7iscksWXiSqt8rYGPy +5V6548r6f1CGPqI0GAwJaCgRHOThuVw+R7oyPxjMW4T182t0xHJ04eOLoEq9jWYv +6q012iDTiIJh8BIitrzQ1aTsr1SIJSQ8p22xcik/Plemf1WvbibG/ufMQFxRRIEK +eN5KzlW/HdXZt1bv8Hb/C3m1r737qWmRRpdogBQ2HbN/uymYNqUg+oJgYjOk7Na6 +B6duxc8UpufWkjTYgfX8HV2qXB72o007uPc5AgMBAAGjgZcwgZQwDwYDVR0TAQH/ +BAUwAwEB/zBSBgNVHSAESzBJMEcGBFUdIAAwPzA9BggrBgEFBQcCARYxaHR0cDov +L3d3dy5wa2lvdmVyaGVpZC5ubC9wb2xpY2llcy9yb290LXBvbGljeS1HMjAOBgNV +HQ8BAf8EBAMCAQYwHQYDVR0OBBYEFJFoMocVHYnitfGsNig0jQt8YojrMA0GCSqG +SIb3DQEBCwUAA4ICAQCoQUpnKpKBglBu4dfYszk78wIVCVBR7y29JHuIhjv5tLyS +CZa59sCrI2AGeYwRTlHSeYAz+51IvuxBQ4EffkdAHOV6CMqqi3WtFMTC6GY8ggen +5ieCWxjmD27ZUD6KQhgpxrRW/FYQoAUXvQwjf/ST7ZwaUb7dRUG/kSS0H4zpX897 +IZmflZ85OkYcbPnNe5yQzSipx6lVu6xiNGI1E0sUOlWDuYaNkqbG9AclVMwWVxJK +gnjIFNkXgiYtXSAfea7+1HAWFpWD2DU5/1JddRwWxRNVz0fMdWVSSt7wsKfkCpYL ++63C4iWEst3kvX5ZbJvw8NjnyvLplzh+ib7M+zkXYT9y2zqR2GUBGR2tUKRXCnxL +vJxxcypFURmFzI79R6d0lR2o0a9OF7FpJsKqeFdbxU2n5Z4FF5TKsl+gSRiNNOkm +bEgeqmiSBeGCc1qb3AdbCG19ndeNIdn8FCCqwkXfP+cAslHkwvgFuXkajDTznlvk +N1trSt8sV4pAWja63XVECDdCcAz+3F4hoKOKwJCcaNpQ5kUQR3i2TtJlycM33+FC +Y7BXN0Ute4qcvwXqZVUz9zkQxSgqIXobisQk+T8VyJoVIPVVYpbtbZNQvOSqeK3Z +ywplh6ZmwcSBo3c6WB4L7oOLnR7SUqTMHW+wmG2UMbX4cQrcufx9MmDm66+KAQ== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFdDCCA1ygAwIBAgIEAJiiOTANBgkqhkiG9w0BAQsFADBaMQswCQYDVQQGEwJO +TDEeMBwGA1UECgwVU3RhYXQgZGVyIE5lZGVybGFuZGVuMSswKQYDVQQDDCJTdGFh +dCBkZXIgTmVkZXJsYW5kZW4gUm9vdCBDQSAtIEczMB4XDTEzMTExNDExMjg0MloX +DTI4MTExMzIzMDAwMFowWjELMAkGA1UEBhMCTkwxHjAcBgNVBAoMFVN0YWF0IGRl +ciBOZWRlcmxhbmRlbjErMCkGA1UEAwwiU3RhYXQgZGVyIE5lZGVybGFuZGVuIFJv +b3QgQ0EgLSBHMzCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAL4yolQP +cPssXFnrbMSkUeiFKrPMSjTysF/zDsccPVMeiAho2G89rcKezIJnByeHaHE6n3WW +IkYFsO2tx1ueKt6c/DrGlaf1F2cY5y9JCAxcz+bMNO14+1Cx3Gsy8KL+tjzk7FqX +xz8ecAgwoNzFs21v0IJyEavSgWhZghe3eJJg+szeP4TrjTgzkApyI/o1zCZxMdFy +KJLZWyNtZrVtB0LrpjPOktvA9mxjeM3KTj215VKb8b475lRgsGYeCasH/lSJEULR +9yS6YHgamPfJEf0WwTUaVHXvQ9Plrk7O53vDxk5hUUurmkVLoR9BvUhTFXFkC4az +5S6+zqQbwSmEorXLCCN2QyIkHxcE1G6cxvx/K2Ya7Irl1s9N9WMJtxU51nus6+N8 +6U78dULI7ViVDAZCopz35HCz33JvWjdAidiFpNfxC95DGdRKWCyMijmev4SH8RY7 +Ngzp07TKbBlBUgmhHbBqv4LvcFEhMtwFdozL92TkA1CvjJFnq8Xy7ljY3r735zHP +bMk7ccHViLVlvMDoFxcHErVc0qsgk7TmgoNwNsXNo42ti+yjwUOH5kPiNL6VizXt +BznaqB16nzaeErAMZRKQFWDZJkBE41ZgpRDUajz9QdwOWke275dhdU/Z/seyHdTt +XUmzqWrLZoQT1Vyg3N9udwbRcXXIV2+vD3dbAgMBAAGjQjBAMA8GA1UdEwEB/wQF +MAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBRUrfrHkleuyjWcLhL75Lpd +INyUVzANBgkqhkiG9w0BAQsFAAOCAgEAMJmdBTLIXg47mAE6iqTnB/d6+Oea31BD +U5cqPco8R5gu4RV78ZLzYdqQJRZlwJ9UXQ4DO1t3ApyEtg2YXzTdO2PCwyiBwpwp +LiniyMMB8jPqKqrMCQj3ZWfGzd/TtiunvczRDnBfuCPRy5FOCvTIeuXZYzbB1N/8 +Ipf3YF3qKS9Ysr1YvY2WTxB1v0h7PVGHoTx0IsL8B3+A3MSs/mrBcDCw6Y5p4ixp +gZQJut3+TcCDjJRYwEYgr5wfAvg1VUkvRtTA8KCWAg8zxXHzniN9lLf9OtMJgwYh +/WA9rjLA0u6NpvDntIJ8CsxwyXmA+P5M9zWEGYox+wrZ13+b8KKaa8MFSu1BYBQw +0aoRQm7TIwIEC8Zl3d1Sd9qBa7Ko+gE4uZbqKmxnl4mUnrzhVNXkanjvSr0rmj1A +fsbAddJu+2gw7OyLnflJNZoaLNmzlTnVHpL3prllL+U9bTpITAjc5CgSKL59NVzq +4BZ+Extq1z7XnvwtdbLBFNUjA9tbbws+eC8N3jONFrdI54OagQ97wUNNVQQXOEpR +1VmiiXTTn74eS9fGbbeIJG9gkaSChVtWQbzQRKtqE77RLFi3EjNYsjdj3BP1lB0/ +QFH1T/U67cjF68IeHRaVesd+QnGTbksVtzDfqu1XhUisHWrdOWnk4Xl4vs4Fv6EM +94B7IWcnMFk= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEDzCCAvegAwIBAgIBADANBgkqhkiG9w0BAQUFADBoMQswCQYDVQQGEwJVUzEl +MCMGA1UEChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEyMDAGA1UECxMp +U3RhcmZpZWxkIENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQw +NjI5MTczOTE2WhcNMzQwNjI5MTczOTE2WjBoMQswCQYDVQQGEwJVUzElMCMGA1UE +ChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEyMDAGA1UECxMpU3RhcmZp +ZWxkIENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwggEgMA0GCSqGSIb3 +DQEBAQUAA4IBDQAwggEIAoIBAQC3Msj+6XGmBIWtDBFk385N78gDGIc/oav7PKaf +8MOh2tTYbitTkPskpD6E8J7oX+zlJ0T1KKY/e97gKvDIr1MvnsoFAZMej2YcOadN ++lq2cwQlZut3f+dZxkqZJRRU6ybH838Z1TBwj6+wRir/resp7defqgSHo9T5iaU0 +X9tDkYI22WY8sbi5gv2cOj4QyDvvBmVmepsZGD3/cVE8MC5fvj13c7JdBmzDI1aa +K4UmkhynArPkPw2vCHmCuDY96pzTNbO8acr1zJ3o/WSNF4Azbl5KXZnJHoe0nRrA +1W4TNSNe35tfPe/W93bC6j67eA0cQmdrBNj41tpvi/JEoAGrAgEDo4HFMIHCMB0G +A1UdDgQWBBS/X7fRzt0fhvRbVazc1xDCDqmI5zCBkgYDVR0jBIGKMIGHgBS/X7fR +zt0fhvRbVazc1xDCDqmI56FspGowaDELMAkGA1UEBhMCVVMxJTAjBgNVBAoTHFN0 +YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAsTKVN0YXJmaWVsZCBD +bGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5ggEAMAwGA1UdEwQFMAMBAf8w +DQYJKoZIhvcNAQEFBQADggEBAAWdP4id0ckaVaGsafPzWdqbAYcaT1epoXkJKtv3 +L7IezMdeatiDh6GX70k1PncGQVhiv45YuApnP+yz3SFmH8lU+nLMPUxA2IGvd56D +eruix/U0F47ZEUD0/CwqTRV/p2JdLiXTAAsgGh1o+Re49L2L7ShZ3U0WixeDyLJl +xy16paq8U4Zt3VekyvggQQto8PT7dL5WXXp59fkdheMtlb71cZBDzI0fmgAKhynp +VSJYACPq4xJDKVtHCN2MQWplBqjlIapBtJUhlbl90TSrE9atvNziPTnNvT51cKEY +WQPJIrSPnNVeKtelttQKbfi3QBFGmh95DmK/D5fs4C8fF5Q= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIID3TCCAsWgAwIBAgIBADANBgkqhkiG9w0BAQsFADCBjzELMAkGA1UEBhMCVVMx +EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxJTAjBgNVBAoT +HFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAMTKVN0YXJmaWVs +ZCBSb290IENlcnRpZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5MDkwMTAwMDAw +MFoXDTM3MTIzMTIzNTk1OVowgY8xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdBcml6 +b25hMRMwEQYDVQQHEwpTY290dHNkYWxlMSUwIwYDVQQKExxTdGFyZmllbGQgVGVj +aG5vbG9naWVzLCBJbmMuMTIwMAYDVQQDEylTdGFyZmllbGQgUm9vdCBDZXJ0aWZp +Y2F0ZSBBdXRob3JpdHkgLSBHMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC +ggEBAL3twQP89o/8ArFvW59I2Z154qK3A2FWGMNHttfKPTUuiUP3oWmb3ooa/RMg +nLRJdzIpVv257IzdIvpy3Cdhl+72WoTsbhm5iSzchFvVdPtrX8WJpRBSiUZV9Lh1 +HOZ/5FSuS/hVclcCGfgXcVnrHigHdMWdSL5stPSksPNkN3mSwOxGXn/hbVNMYq/N +Hwtjuzqd+/x5AJhhdM8mgkBj87JyahkNmcrUDnXMN/uLicFZ8WJ/X7NfZTD4p7dN +dloedl40wOiWVpmKs/B/pM293DIxfJHP4F8R+GuqSVzRmZTRouNjWwl2tVZi4Ut0 +HZbUJtQIBFnQmA4O5t78w+wfkPECAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFHwMMh+n2TB/xH1oo2Kooc6rB1snMA0G +CSqGSIb3DQEBCwUAA4IBAQARWfolTwNvlJk7mh+ChTnUdgWUXuEok21iXQnCoKjU +sHU48TRqneSfioYmUeYs0cYtbpUgSpIB7LiKZ3sx4mcujJUDJi5DnUox9g61DLu3 +4jd/IroAow57UvtruzvE03lRTs2Q9GcHGcg8RnoNAX3FWOdt5oUwF5okxBDgBPfg +8n/Uqgr/Qh037ZTlZFkSIHc40zI+OIF1lnP6aI+xy84fxez6nH7PfrHxBy22/L/K +pL/QlwVKvOoYKAKQvVR4CSFx09F9HdkWsKlhPdAKACL8x3vLCWRFCztAgfd9fDL1 +mMpYjn0q7pBZc2T5NnReJaH1ZgUufzkVqSr7UIuOhWn0 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIID7zCCAtegAwIBAgIBADANBgkqhkiG9w0BAQsFADCBmDELMAkGA1UEBhMCVVMx +EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxJTAjBgNVBAoT +HFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xOzA5BgNVBAMTMlN0YXJmaWVs +ZCBTZXJ2aWNlcyBSb290IENlcnRpZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5 +MDkwMTAwMDAwMFoXDTM3MTIzMTIzNTk1OVowgZgxCzAJBgNVBAYTAlVTMRAwDgYD +VQQIEwdBcml6b25hMRMwEQYDVQQHEwpTY290dHNkYWxlMSUwIwYDVQQKExxTdGFy +ZmllbGQgVGVjaG5vbG9naWVzLCBJbmMuMTswOQYDVQQDEzJTdGFyZmllbGQgU2Vy +dmljZXMgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgLSBHMjCCASIwDQYJKoZI +hvcNAQEBBQADggEPADCCAQoCggEBANUMOsQq+U7i9b4Zl1+OiFOxHz/Lz58gE20p +OsgPfTz3a3Y4Y9k2YKibXlwAgLIvWX/2h/klQ4bnaRtSmpDhcePYLQ1Ob/bISdm2 +8xpWriu2dBTrz/sm4xq6HZYuajtYlIlHVv8loJNwU4PahHQUw2eeBGg6345AWh1K +Ts9DkTvnVtYAcMtS7nt9rjrnvDH5RfbCYM8TWQIrgMw0R9+53pBlbQLPLJGmpufe +hRhJfGZOozptqbXuNC66DQO4M99H67FrjSXZm86B0UVGMpZwh94CDklDhbZsc7tk +6mFBrMnUVN+HL8cisibMn1lUaJ/8viovxFUcdUBgF4UCVTmLfwUCAwEAAaNCMEAw +DwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFJxfAN+q +AdcwKziIorhtSpzyEZGDMA0GCSqGSIb3DQEBCwUAA4IBAQBLNqaEd2ndOxmfZyMI +bw5hyf2E3F/YNoHN2BtBLZ9g3ccaaNnRbobhiCPPE95Dz+I0swSdHynVv/heyNXB +ve6SbzJ08pGCL72CQnqtKrcgfU28elUSwhXqvfdqlS5sdJ/PHLTyxQGjhdByPq1z +qwubdQxtRbeOlKyWN7Wg0I8VRw7j6IPdj/3vQQF3zCepYoUz8jcI73HPdwbeyBkd +iEDPfUYd/x7H4c7/I9vG+o1VTqkC50cRRj70/b17KSa7qWFiNyi2LSr2EIZkyXCn +0q23KXB56jzaYyWf/Wi3MOxw+3WKt21gZ7IeyLnp2KhvAotnDU0mV3HaIPzBSlCN +sSi6 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIHyTCCBbGgAwIBAgIBATANBgkqhkiG9w0BAQUFADB9MQswCQYDVQQGEwJJTDEW +MBQGA1UEChMNU3RhcnRDb20gTHRkLjErMCkGA1UECxMiU2VjdXJlIERpZ2l0YWwg +Q2VydGlmaWNhdGUgU2lnbmluZzEpMCcGA1UEAxMgU3RhcnRDb20gQ2VydGlmaWNh +dGlvbiBBdXRob3JpdHkwHhcNMDYwOTE3MTk0NjM2WhcNMzYwOTE3MTk0NjM2WjB9 +MQswCQYDVQQGEwJJTDEWMBQGA1UEChMNU3RhcnRDb20gTHRkLjErMCkGA1UECxMi +U2VjdXJlIERpZ2l0YWwgQ2VydGlmaWNhdGUgU2lnbmluZzEpMCcGA1UEAxMgU3Rh +cnRDb20gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwggIiMA0GCSqGSIb3DQEBAQUA +A4ICDwAwggIKAoICAQDBiNsJvGxGfHiflXu1M5DycmLWwTYgIiRezul38kMKogZk +pMyONvg45iPwbm2xPN1yo4UcodM9tDMr0y+v/uqwQVlntsQGfQqedIXWeUyAN3rf +OQVSWff0G0ZDpNKFhdLDcfN1YjS6LIp/Ho/u7TTQEceWzVI9ujPW3U3eCztKS5/C +Ji/6tRYccjV3yjxd5srhJosaNnZcAdt0FCX+7bWgiA/deMotHweXMAEtcnn6RtYT +Kqi5pquDSR3l8u/d5AGOGAqPY1MWhWKpDhk6zLVmpsJrdAfkK+F2PrRt2PZE4XNi +HzvEvqBTViVsUQn3qqvKv3b9bZvzndu/PWa8DFaqr5hIlTpL36dYUNk4dalb6kMM +Av+Z6+hsTXBbKWWc3apdzK8BMewM69KN6Oqce+Zu9ydmDBpI125C4z/eIT574Q1w ++2OqqGwaVLRcJXrJosmLFqa7LH4XXgVNWG4SHQHuEhANxjJ/GP/89PrNbpHoNkm+ +Gkhpi8KWTRoSsmkXwQqQ1vp5Iki/untp+HDH+no32NgN0nZPV/+Qt+OR0t3vwmC3 +Zzrd/qqc8NSLf3Iizsafl7b4r4qgEKjZ+xjGtrVcUjyJthkqcwEKDwOzEmDyei+B +26Nu/yYwl/WL3YlXtq09s68rxbd2AvCl1iuahhQqcvbjM4xdCUsT37uMdBNSSwID +AQABo4ICUjCCAk4wDAYDVR0TBAUwAwEB/zALBgNVHQ8EBAMCAa4wHQYDVR0OBBYE +FE4L7xqkQFulF2mHMMo0aEPQQa7yMGQGA1UdHwRdMFswLKAqoCiGJmh0dHA6Ly9j +ZXJ0LnN0YXJ0Y29tLm9yZy9zZnNjYS1jcmwuY3JsMCugKaAnhiVodHRwOi8vY3Js +LnN0YXJ0Y29tLm9yZy9zZnNjYS1jcmwuY3JsMIIBXQYDVR0gBIIBVDCCAVAwggFM +BgsrBgEEAYG1NwEBATCCATswLwYIKwYBBQUHAgEWI2h0dHA6Ly9jZXJ0LnN0YXJ0 +Y29tLm9yZy9wb2xpY3kucGRmMDUGCCsGAQUFBwIBFilodHRwOi8vY2VydC5zdGFy +dGNvbS5vcmcvaW50ZXJtZWRpYXRlLnBkZjCB0AYIKwYBBQUHAgIwgcMwJxYgU3Rh +cnQgQ29tbWVyY2lhbCAoU3RhcnRDb20pIEx0ZC4wAwIBARqBl0xpbWl0ZWQgTGlh +YmlsaXR5LCByZWFkIHRoZSBzZWN0aW9uICpMZWdhbCBMaW1pdGF0aW9ucyogb2Yg +dGhlIFN0YXJ0Q29tIENlcnRpZmljYXRpb24gQXV0aG9yaXR5IFBvbGljeSBhdmFp +bGFibGUgYXQgaHR0cDovL2NlcnQuc3RhcnRjb20ub3JnL3BvbGljeS5wZGYwEQYJ +YIZIAYb4QgEBBAQDAgAHMDgGCWCGSAGG+EIBDQQrFilTdGFydENvbSBGcmVlIFNT +TCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTANBgkqhkiG9w0BAQUFAAOCAgEAFmyZ +9GYMNPXQhV59CuzaEE44HF7fpiUFS5Eyweg78T3dRAlbB0mKKctmArexmvclmAk8 +jhvh3TaHK0u7aNM5Zj2gJsfyOZEdUauCe37Vzlrk4gNXcGmXCPleWKYK34wGmkUW +FjgKXlf2Ysd6AgXmvB618p70qSmD+LIU424oh0TDkBreOKk8rENNZEXO3SipXPJz +ewT4F+irsfMuXGRuczE6Eri8sxHkfY+BUZo7jYn0TZNmezwD7dOaHZrzZVD1oNB1 +ny+v8OqCQ5j4aZyJecRDjkZy42Q2Eq/3JR44iZB3fsNrarnDy0RLrHiQi+fHLB5L +EUTINFInzQpdn4XBidUaePKVEFMy3YCEZnXZtWgo+2EuvoSoOMCZEoalHmdkrQYu +L6lwhceWD3yJZfWOQ1QOq92lgDmUYMA0yZZwLKMS9R9Ie70cfmu3nZD0Ijuu+Pwq +yvqCUqDvr0tVk+vBtfAii6w0TiYiBKGHLHVKt+V9E9e4DGTANtLJL4YSjCMJwRuC +O3NJo2pXh5Tl1njFmUNj403gdy3hZZlyaQQaRwnmDwFWJPsfvw55qVguucQJAX6V +um0ABj6y6koQOdjQK/W/7HW/lwLFCRsI3FU34oH7N4RDYiDK51ZLZer+bMEkkySh +NOsF/5oirpt9P/FlUQqmMGqz9IgcgA38corog14= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIHhzCCBW+gAwIBAgIBLTANBgkqhkiG9w0BAQsFADB9MQswCQYDVQQGEwJJTDEW +MBQGA1UEChMNU3RhcnRDb20gTHRkLjErMCkGA1UECxMiU2VjdXJlIERpZ2l0YWwg +Q2VydGlmaWNhdGUgU2lnbmluZzEpMCcGA1UEAxMgU3RhcnRDb20gQ2VydGlmaWNh +dGlvbiBBdXRob3JpdHkwHhcNMDYwOTE3MTk0NjM3WhcNMzYwOTE3MTk0NjM2WjB9 +MQswCQYDVQQGEwJJTDEWMBQGA1UEChMNU3RhcnRDb20gTHRkLjErMCkGA1UECxMi +U2VjdXJlIERpZ2l0YWwgQ2VydGlmaWNhdGUgU2lnbmluZzEpMCcGA1UEAxMgU3Rh +cnRDb20gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwggIiMA0GCSqGSIb3DQEBAQUA +A4ICDwAwggIKAoICAQDBiNsJvGxGfHiflXu1M5DycmLWwTYgIiRezul38kMKogZk +pMyONvg45iPwbm2xPN1yo4UcodM9tDMr0y+v/uqwQVlntsQGfQqedIXWeUyAN3rf +OQVSWff0G0ZDpNKFhdLDcfN1YjS6LIp/Ho/u7TTQEceWzVI9ujPW3U3eCztKS5/C +Ji/6tRYccjV3yjxd5srhJosaNnZcAdt0FCX+7bWgiA/deMotHweXMAEtcnn6RtYT +Kqi5pquDSR3l8u/d5AGOGAqPY1MWhWKpDhk6zLVmpsJrdAfkK+F2PrRt2PZE4XNi +HzvEvqBTViVsUQn3qqvKv3b9bZvzndu/PWa8DFaqr5hIlTpL36dYUNk4dalb6kMM +Av+Z6+hsTXBbKWWc3apdzK8BMewM69KN6Oqce+Zu9ydmDBpI125C4z/eIT574Q1w ++2OqqGwaVLRcJXrJosmLFqa7LH4XXgVNWG4SHQHuEhANxjJ/GP/89PrNbpHoNkm+ +Gkhpi8KWTRoSsmkXwQqQ1vp5Iki/untp+HDH+no32NgN0nZPV/+Qt+OR0t3vwmC3 +Zzrd/qqc8NSLf3Iizsafl7b4r4qgEKjZ+xjGtrVcUjyJthkqcwEKDwOzEmDyei+B +26Nu/yYwl/WL3YlXtq09s68rxbd2AvCl1iuahhQqcvbjM4xdCUsT37uMdBNSSwID +AQABo4ICEDCCAgwwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYD +VR0OBBYEFE4L7xqkQFulF2mHMMo0aEPQQa7yMB8GA1UdIwQYMBaAFE4L7xqkQFul +F2mHMMo0aEPQQa7yMIIBWgYDVR0gBIIBUTCCAU0wggFJBgsrBgEEAYG1NwEBATCC +ATgwLgYIKwYBBQUHAgEWImh0dHA6Ly93d3cuc3RhcnRzc2wuY29tL3BvbGljeS5w +ZGYwNAYIKwYBBQUHAgEWKGh0dHA6Ly93d3cuc3RhcnRzc2wuY29tL2ludGVybWVk +aWF0ZS5wZGYwgc8GCCsGAQUFBwICMIHCMCcWIFN0YXJ0IENvbW1lcmNpYWwgKFN0 +YXJ0Q29tKSBMdGQuMAMCAQEagZZMaW1pdGVkIExpYWJpbGl0eSwgcmVhZCB0aGUg +c2VjdGlvbiAqTGVnYWwgTGltaXRhdGlvbnMqIG9mIHRoZSBTdGFydENvbSBDZXJ0 +aWZpY2F0aW9uIEF1dGhvcml0eSBQb2xpY3kgYXZhaWxhYmxlIGF0IGh0dHA6Ly93 +d3cuc3RhcnRzc2wuY29tL3BvbGljeS5wZGYwEQYJYIZIAYb4QgEBBAQDAgAHMDgG +CWCGSAGG+EIBDQQrFilTdGFydENvbSBGcmVlIFNTTCBDZXJ0aWZpY2F0aW9uIEF1 +dGhvcml0eTANBgkqhkiG9w0BAQsFAAOCAgEAjo/n3JR5fPGFf59Jb2vKXfuM/gTF +wWLRfUKKvFO3lANmMD+x5wqnUCBVJX92ehQN6wQOQOY+2IirByeDqXWmN3PH/UvS +Ta0XQMhGvjt/UfzDtgUx3M2FIk5xt/JxXrAaxrqTi3iSSoX4eA+D/i+tLPfkpLst +0OcNOrg+zvZ49q5HJMqjNTbOx8aHmNrs++myziebiMMEofYLWWivydsQD032ZGNc +pRJvkrKTlMeIFw6Ttn5ii5B/q06f/ON1FE8qMt9bDeD1e5MNq6HPh+GlBEXoPBKl +CcWw0bdT82AUuoVpaiF8H3VhFyAXe2w7QSlc4axa0c2Mm+tgHRns9+Ww2vl5GKVF +P0lDV9LdJNUso/2RjSe15esUBppMeyG7Oq0wBhjA2MFrLH9ZXF2RsXAiV+uKa0hK +1Q8p7MZAwC+ITGgBF3f0JBlPvfrhsiAhS90a2Cl9qrjeVOwhVYBsHvUwyKMQ5bLm +KhQxw4UtjJixhlpPiVktucf3HMiKf8CdBUrmQk9io20ppB+Fq9vlgcitKj1MXVuE +JnHEhV5xJMqlG2zYYdMa4FTbzrqpMrUi9nNBCV24F10OD5mQ1kfabwo6YigUZ4LZ +8dCAWZvLMdibD4x3TrVoivJs9iQOLWxwxXPR3hTQcY+203sC9uO41Alua551hDnm +fyWl8kgAwKQB2j8= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFYzCCA0ugAwIBAgIBOzANBgkqhkiG9w0BAQsFADBTMQswCQYDVQQGEwJJTDEW +MBQGA1UEChMNU3RhcnRDb20gTHRkLjEsMCoGA1UEAxMjU3RhcnRDb20gQ2VydGlm +aWNhdGlvbiBBdXRob3JpdHkgRzIwHhcNMTAwMTAxMDEwMDAxWhcNMzkxMjMxMjM1 +OTAxWjBTMQswCQYDVQQGEwJJTDEWMBQGA1UEChMNU3RhcnRDb20gTHRkLjEsMCoG +A1UEAxMjU3RhcnRDb20gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgRzIwggIiMA0G +CSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC2iTZbB7cgNr2Cu+EWIAOVeq8Oo1XJ +JZlKxdBWQYeQTSFgpBSHO839sj60ZwNq7eEPS8CRhXBF4EKe3ikj1AENoBB5uNsD +vfOpL9HG4A/LnooUCri99lZi8cVytjIl2bLzvWXFDSxu1ZJvGIsAQRSCb0AgJnoo +D/Uefyf3lLE3PbfHkffiAez9lInhzG7TNtYKGXmu1zSCZf98Qru23QumNK9LYP5/ +Q0kGi4xDuFby2X8hQxfqp0iVAXV16iulQ5XqFYSdCI0mblWbq9zSOdIxHWDirMxW +RST1HFSr7obdljKF+ExP6JV2tgXdNiNnvP8V4so75qbsO+wmETRIjfaAKxojAuuK +HDp2KntWFhxyKrOq42ClAJ8Em+JvHhRYW6Vsi1g8w7pOOlz34ZYrPu8HvKTlXcxN +nw3h3Kq74W4a7I/htkxNeXJdFzULHdfBR9qWJODQcqhaX2YtENwvKhOuJv4KHBnM +0D4LnMgJLvlblnpHnOl68wVQdJVznjAJ85eCXuaPOQgeWeU1FEIT/wCc976qUM/i +UUjXuG+v+E5+M5iSFGI6dWPPe/regjupuznixL0sAA7IF6wT700ljtizkC+p2il9 +Ha90OrInwMEePnWjFqmveiJdnxMaz6eg6+OGCtP95paV1yPIN93EfKo2rJgaErHg +TuixO/XWb/Ew1wIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQE +AwIBBjAdBgNVHQ4EFgQUS8W0QGutHLOlHGVuRjaJhwUMDrYwDQYJKoZIhvcNAQEL +BQADggIBAHNXPyzVlTJ+N9uWkusZXn5T50HsEbZH77Xe7XRcxfGOSeD8bpkTzZ+K +2s06Ctg6Wgk/XzTQLwPSZh0avZyQN8gMjgdalEVGKua+etqhqaRpEpKwfTbURIfX +UfEpY9Z1zRbkJ4kd+MIySP3bmdCPX1R0zKxnNBFi2QwKN4fRoxdIjtIXHfbX/dtl +6/2o1PXWT6RbdejF0mCy2wl+JYt7ulKSnj7oxXehPOBKc2thz4bcQ///If4jXSRK +9dNtD2IEBVeC2m6kMyV5Sy5UGYvMLD0w6dEG/+gyRr61M3Z3qAFdlsHB1b6uJcDJ +HgoJIIihDsnzb02CVAAgp9KP5DlUFy6NHrgbuxu9mk47EDTcnIhT76IxW1hPkWLI +wpqazRVdOKnWvvgTtZ8SafJQYqz7Fzf07rh1Z2AQ+4NQ+US1dZxAF7L+/XldblhY +XzD8AK6vM8EOTmy6p6ahfzLbOOCxchcKK5HsamMm7YnUeMx0HgX4a/6ManY5Ka5l +IxKVCCIcl85bBu4M4ru8H0ST9tg4RQUh7eStqxK2A6RCLi3ECToDZ2mEmuFZkIoo +hdVddLHRDiBYmxOlsGOm7XtH/UVVMKTumtTm4ofvmMkyghEpIrwACjFeLQ/Ajulr +so8uBtjRkcfGEvRM/TAXw8HaOFvjqermobp573PYtlNXLfbQ4ddI +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFujCCA6KgAwIBAgIJALtAHEP1Xk+wMA0GCSqGSIb3DQEBBQUAMEUxCzAJBgNV +BAYTAkNIMRUwEwYDVQQKEwxTd2lzc1NpZ24gQUcxHzAdBgNVBAMTFlN3aXNzU2ln +biBHb2xkIENBIC0gRzIwHhcNMDYxMDI1MDgzMDM1WhcNMzYxMDI1MDgzMDM1WjBF +MQswCQYDVQQGEwJDSDEVMBMGA1UEChMMU3dpc3NTaWduIEFHMR8wHQYDVQQDExZT +d2lzc1NpZ24gR29sZCBDQSAtIEcyMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIIC +CgKCAgEAr+TufoskDhJuqVAtFkQ7kpJcyrhdhJJCEyq8ZVeCQD5XJM1QiyUqt2/8 +76LQwB8CJEoTlo8jE+YoWACjR8cGp4QjK7u9lit/VcyLwVcfDmJlD909Vopz2q5+ +bbqBHH5CjCA12UNNhPqE21Is8w4ndwtrvxEvcnifLtg+5hg3Wipy+dpikJKVyh+c +6bM8K8vzARO/Ws/BtQpgvd21mWRTuKCWs2/iJneRjOBiEAKfNA+k1ZIzUd6+jbqE +emA8atufK+ze3gE/bk3lUIbLtK/tREDFylqM2tIrfKjuvqblCqoOpd8FUrdVxyJd +MmqXl2MT28nbeTZ7hTpKxVKJ+STnnXepgv9VHKVxaSvRAiTysybUa9oEVeXBCsdt +MDeQKuSeFDNeFhdVxVu1yzSJkvGdJo+hB9TGsnhQ2wwMC3wLjEHXuendjIj3o02y +MszYF9rNt85mndT9Xv+9lz4pded+p2JYryU0pUHHPbwNUMoDAw8IWh+Vc3hiv69y +FGkOpeUDDniOJihC8AcLYiAQZzlG+qkDzAQ4embvIIO1jEpWjpEA/I5cgt6IoMPi +aG59je883WX0XaxR7ySArqpWl2/5rX3aYT+YdzylkbYcjCbaZaIJbcHiVOO5ykxM +gI93e2CaHt+28kgeDrpOVG2Y4OGiGqJ3UM/EY5LsRxmd6+ZrzsECAwEAAaOBrDCB +qTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWyV7 +lqRlUX64OfPAeGZe6Drn8O4wHwYDVR0jBBgwFoAUWyV7lqRlUX64OfPAeGZe6Drn +8O4wRgYDVR0gBD8wPTA7BglghXQBWQECAQEwLjAsBggrBgEFBQcCARYgaHR0cDov +L3JlcG9zaXRvcnkuc3dpc3NzaWduLmNvbS8wDQYJKoZIhvcNAQEFBQADggIBACe6 +45R88a7A3hfm5djV9VSwg/S7zV4Fe0+fdWavPOhWfvxyeDgD2StiGwC5+OlgzczO +UYrHUDFu4Up+GC9pWbY9ZIEr44OE5iKHjn3g7gKZYbge9LgriBIWhMIxkziWMaa5 +O1M/wySTVltpkuzFwbs4AOPsF6m43Md8AYOfMke6UiI0HTJ6CVanfCU2qT1L2sCC +bwq7EsiHSycR+R4tx5M/nttfJmtS2S6K8RTGRI0Vqbe/vd6mGu6uLftIdxf+u+yv +GPUqUfA5hJeVbG4bwyvEdGB5JbAKJ9/fXtI5z0V9QkvfsywexcZdylU6oJxpmo/a +77KwPJ+HbBIrZXAVUjEaJM9vMSNQH4xPjyPDdEFjHFWoFN0+4FFQz/EbMFYOkrCC +hdiDyyJkvC24JdVUorgG6q2SpCSgwYa1ShNqR88uC1aVVMvOmttqtKay20EIhid3 +92qgQmwLOM7XdVAyksLfKzAiSNDVQTglXaTpXZ/GlHXQRf0wl0OPkKsKx4ZzYEpp +Ld6leNcG2mqeSz53OiATIgHQv2ieY2BrNU0LbbqhPcCT4H8js1WtciVORvnSFu+w +ZMEBnunKoGqYDs/YYPIvSbjkQuE4NRb0yG5P94FW6LqjviOvrv1vA+ACOzB2+htt +Qc8Bsem4yWb02ybzOqR08kkkW8mw0FfB+j564ZfJ +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFvTCCA6WgAwIBAgIITxvUL1S7L0swDQYJKoZIhvcNAQEFBQAwRzELMAkGA1UE +BhMCQ0gxFTATBgNVBAoTDFN3aXNzU2lnbiBBRzEhMB8GA1UEAxMYU3dpc3NTaWdu +IFNpbHZlciBDQSAtIEcyMB4XDTA2MTAyNTA4MzI0NloXDTM2MTAyNTA4MzI0Nlow +RzELMAkGA1UEBhMCQ0gxFTATBgNVBAoTDFN3aXNzU2lnbiBBRzEhMB8GA1UEAxMY +U3dpc3NTaWduIFNpbHZlciBDQSAtIEcyMIICIjANBgkqhkiG9w0BAQEFAAOCAg8A +MIICCgKCAgEAxPGHf9N4Mfc4yfjDmUO8x/e8N+dOcbpLj6VzHVxumK4DV644N0Mv +Fz0fyM5oEMF4rhkDKxD6LHmD9ui5aLlV8gREpzn5/ASLHvGiTSf5YXu6t+WiE7br +YT7QbNHm+/pe7R20nqA1W6GSy/BJkv6FCgU+5tkL4k+73JU3/JHpMjUi0R86TieF +nbAVlDLaYQ1HTWBCrpJH6INaUFjpiou5XaHc3ZlKHzZnu0jkg7Y360g6rw9njxcH +6ATK72oxh9TAtvmUcXtnZLi2kUpCe2UuMGoM9ZDulebyzYLs2aFK7PayS+VFheZt +eJMELpyCbTapxDFkH4aDCyr0NQp4yVXPQbBH6TCfmb5hqAaEuSh6XzjZG6k4sIN/ +c8HDO0gqgg8hm7jMqDXDhBuDsz6+pJVpATqJAHgE2cn0mRmrVn5bi4Y5FZGkECwJ +MoBgs5PAKrYYC51+jUnyEEp/+dVGLxmSo5mnJqy7jDzmDrxHB9xzUfFwZC8I+bRH +HTBsROopN4WSaGa8gzj+ezku01DwH/teYLappvonQfGbGHLy9YR0SslnxFSuSGTf +jNFusB3hB48IHpmccelM2KX3RxIfdNFRnobzwqIjQAtz20um53MGjMGg6cFZrEb6 +5i/4z3GcRm25xBWNOHkDRUjvxF3XCO6HOSKGsg0PWEP3calILv3q1h8CAwEAAaOB +rDCBqTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU +F6DNweRBtjpbO8tFnb0cwpj6hlgwHwYDVR0jBBgwFoAUF6DNweRBtjpbO8tFnb0c +wpj6hlgwRgYDVR0gBD8wPTA7BglghXQBWQEDAQEwLjAsBggrBgEFBQcCARYgaHR0 +cDovL3JlcG9zaXRvcnkuc3dpc3NzaWduLmNvbS8wDQYJKoZIhvcNAQEFBQADggIB +AHPGgeAn0i0P4JUw4ppBf1AsX19iYamGamkYDHRJ1l2E6kFSGG9YrVBWIGrGvShp +WJHckRE1qTodvBqlYJ7YH39FkWnZfrt4csEGDyrOj4VwYaygzQu4OSlWhDJOhrs9 +xCrZ1x9y7v5RoSJBsXECYxqCsGKrXlcSH9/L3XWgwF15kIwb4FDm3jH+mHtwX6WQ +2K34ArZv02DdQEsixT2tOnqfGhpHkXkzuoLcMmkDlm4fS/Bx/uNncqCxv1yL5PqZ +IseEuRuNI5c/7SXgz2W79WEE790eslpBIlqhn10s6FvJbakMDHiqYMZWjwFaDGi8 +aRl5xB9+lwW/xekkUV7U1UtT7dkjWjYDZaPBA61BMPNGG4WQr2W11bHkFlt4dR2X +em1ZqSqPe97Dh4kQmUlzeMg9vVE1dCrV8X5pGyq7O70luJpaPXJhkGaH7gzWTdQR +dAtq/gsD/KNVV4n+SsuuWxcFyPKNIzFTONItaj+CuY0IavdeQXRuwxF+B6wpYJE/ +OMpXEA29MC/HpeZBoNquBYeaoKRlbEwJDIm6uNO5wJOKMPqN5ZprFQFOZ6raYlY+ +hAhm0sQ2fac+EPyI4NSA5QC9qvNOBqN6avlicuMJT+ubDgEj8Z+7fNzcbBGXJbLy +tGMU0gYqZ4yD9c7qB9iaah7s5Aq7KkzrCWA5zspi2C5u +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIF2TCCA8GgAwIBAgIQXAuFXAvnWUHfV8w/f52oNjANBgkqhkiG9w0BAQUFADBk +MQswCQYDVQQGEwJjaDERMA8GA1UEChMIU3dpc3Njb20xJTAjBgNVBAsTHERpZ2l0 +YWwgQ2VydGlmaWNhdGUgU2VydmljZXMxGzAZBgNVBAMTElN3aXNzY29tIFJvb3Qg +Q0EgMTAeFw0wNTA4MTgxMjA2MjBaFw0yNTA4MTgyMjA2MjBaMGQxCzAJBgNVBAYT +AmNoMREwDwYDVQQKEwhTd2lzc2NvbTElMCMGA1UECxMcRGlnaXRhbCBDZXJ0aWZp +Y2F0ZSBTZXJ2aWNlczEbMBkGA1UEAxMSU3dpc3Njb20gUm9vdCBDQSAxMIICIjAN +BgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA0LmwqAzZuz8h+BvVM5OAFmUgdbI9 +m2BtRsiMMW8Xw/qabFbtPMWRV8PNq5ZJkCoZSx6jbVfd8StiKHVFXqrWW/oLJdih +FvkcxC7mlSpnzNApbjyFNDhhSbEAn9Y6cV9Nbc5fuankiX9qUvrKm/LcqfmdmUc/ +TilftKaNXXsLmREDA/7n29uj/x2lzZAeAR81sH8A25Bvxn570e56eqeqDFdvpG3F +EzuwpdntMhy0XmeLVNxzh+XTF3xmUHJd1BpYwdnP2IkCb6dJtDZd0KTeByy2dbco +kdaXvij1mB7qWybJvbCXc9qukSbraMH5ORXWZ0sKbU/Lz7DkQnGMU3nn7uHbHaBu +HYwadzVcFh4rUx80i9Fs/PJnB3r1re3WmquhsUvhzDdf/X/NTa64H5xD+SpYVUNF +vJbNcA78yeNmuk6NO4HLFWR7uZToXTNShXEuT46iBhFRyePLoW4xCGQMwtI89Tbo +19AOeCMgkckkKmUpWyL3Ic6DXqTz3kvTaI9GdVyDCW4pa8RwjPWd1yAv/0bSKzjC +L3UcPX7ape8eYIVpQtPM+GP+HkM5haa2Y0EQs3MevNP6yn0WR+Kn1dCjigoIlmJW +bjTb2QK5MHXjBNLnj8KwEUAKrNVxAmKLMb7dxiNYMUJDLXT5xp6mig/p/r+D5kNX +JLrvRjSq1xIBOO0CAwEAAaOBhjCBgzAOBgNVHQ8BAf8EBAMCAYYwHQYDVR0hBBYw +FDASBgdghXQBUwABBgdghXQBUwABMBIGA1UdEwEB/wQIMAYBAf8CAQcwHwYDVR0j +BBgwFoAUAyUv3m+CATpcLNwroWm1Z9SM0/0wHQYDVR0OBBYEFAMlL95vggE6XCzc +K6FptWfUjNP9MA0GCSqGSIb3DQEBBQUAA4ICAQA1EMvspgQNDQ/NwNurqPKIlwzf +ky9NfEBWMXrrpA9gzXrzvsMnjgM+pN0S734edAY8PzHyHHuRMSG08NBsl9Tpl7Ik +Vh5WwzW9iAUPWxAaZOHHgjD5Mq2eUCzneAXQMbFamIp1TpBcahQq4FJHgmDmHtqB +sfsUC1rxn9KVuj7QG9YVHaO+htXbD8BJZLsuUBlL0iT43R4HVtA4oJVwIHaM190e +3p9xxCPvgxNcoyQVTSlAPGrEqdi3pkSlDfTgnXceQHAm/NrZNuR55LU/vJtlvrsR +ls/bxig5OgjOR1tTWsWZ/l2p3e9M1MalrQLmjAcSHm8D0W+go/MpvRLHUKKwf4ip +mXeascClOS5cfGniLLDqN2qk4Vrh9VDlg++luyqI54zb/W1elxmofmZ1a3Hqv7HH +b6D0jqTsNFFbjCYDcKF31QESVwA12yPeDooomf2xEG9L/zgtYE4snOtnta1J7ksf +rK/7DZBaZmBwXarNeNQk7shBoJMBkpxqnvy5JMWzFYJ+vq6VK+uxwNrjAWALXmms +hFZhvnEX/h0TD/7Gh0Xp/jKgGg0TpJRVcaUWi7rKibCyx/yP2FS1k2Kdzs9Z+z0Y +zirLNRWCXf9UIltxUvu3yf5gmwBBZPCqKuy2QkPOiWaByIufOVQDJdMWNY6E0F/6 +MBr1mmz0DlP5OlvRHA== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIF2TCCA8GgAwIBAgIQHp4o6Ejy5e/DfEoeWhhntjANBgkqhkiG9w0BAQsFADBk +MQswCQYDVQQGEwJjaDERMA8GA1UEChMIU3dpc3Njb20xJTAjBgNVBAsTHERpZ2l0 +YWwgQ2VydGlmaWNhdGUgU2VydmljZXMxGzAZBgNVBAMTElN3aXNzY29tIFJvb3Qg +Q0EgMjAeFw0xMTA2MjQwODM4MTRaFw0zMTA2MjUwNzM4MTRaMGQxCzAJBgNVBAYT +AmNoMREwDwYDVQQKEwhTd2lzc2NvbTElMCMGA1UECxMcRGlnaXRhbCBDZXJ0aWZp +Y2F0ZSBTZXJ2aWNlczEbMBkGA1UEAxMSU3dpc3Njb20gUm9vdCBDQSAyMIICIjAN +BgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAlUJOhJ1R5tMJ6HJaI2nbeHCOFvEr +jw0DzpPMLgAIe6szjPTpQOYXTKueuEcUMncy3SgM3hhLX3af+Dk7/E6J2HzFZ++r +0rk0X2s682Q2zsKwzxNoysjL67XiPS4h3+os1OD5cJZM/2pYmLcX5BtS5X4HAB1f +2uY+lQS3aYg5oUFgJWFLlTloYhyxCwWJwDaCFCE/rtuh/bxvHGCGtlOUSbkrRsVP +ACu/obvLP+DHVxxX6NZp+MEkUp2IVd3Chy50I9AU/SpHWrumnf2U5NGKpV+GY3aF +y6//SSj8gO1MedK75MDvAe5QQQg1I3ArqRa0jG6F6bYRzzHdUyYb3y1aSgJA/MTA +tukxGggo5WDDH8SQjhBiYEQN7Aq+VRhxLKX0srwVYv8c474d2h5Xszx+zYIdkeNL +6yxSNLCK/RJOlrDrcH+eOfdmQrGrrFLadkBXeyq96G4DsguAhYidDMfCd7Camlf0 +uPoTXGiTOmekl9AbmbeGMktg2M7v0Ax/lZ9vh0+Hio5fCHyqW/xavqGRn1V9TrAL +acywlKinh/LTSlDcX3KwFnUey7QYYpqwpzmqm59m2I2mbJYV4+by+PGDYmy7Velh +k6M99bFXi08jsJvllGov34zflVEpYKELKeRcVVi3qPyZ7iVNTA6z00yPhOgpD/0Q +VAKFyPnlw4vP5w8CAwEAAaOBhjCBgzAOBgNVHQ8BAf8EBAMCAYYwHQYDVR0hBBYw +FDASBgdghXQBUwIBBgdghXQBUwIBMBIGA1UdEwEB/wQIMAYBAf8CAQcwHQYDVR0O +BBYEFE0mICKJS9PVpAqhb97iEoHF8TwuMB8GA1UdIwQYMBaAFE0mICKJS9PVpAqh +b97iEoHF8TwuMA0GCSqGSIb3DQEBCwUAA4ICAQAyCrKkG8t9voJXiblqf/P0wS4R +fbgZPnm3qKhyN2abGu2sEzsOv2LwnN+ee6FTSA5BesogpxcbtnjsQJHzQq0Qw1zv +/2BZf82Fo4s9SBwlAjxnffUy6S8w5X2lejjQ82YqZh6NM4OKb3xuqFp1mrjX2lhI +REeoTPpMSQpKwhI3qEAMw8jh0FcNlzKVxzqfl9NX+Ave5XLzo9v/tdhZsnPdTSpx +srpJ9csc1fV5yJmz/MFMdOO0vSk3FQQoHt5FRnDsr7p4DooqzgB53MBfGWcsa0vv +aGgLQ+OswWIJ76bdZWGgr4RVSJFSHMYlkSrQwSIjYVmvRRGFHQEkNI/Ps/8XciAT +woCqISxxOQ7Qj1zB09GOInJGTB2Wrk9xseEFKZZZ9LuedT3PDTcNYtsmjGOpI99n +Bjx8Oto0QuFmtEYE3saWmA9LSHokMnWRn6z3aOkquVVlzl1h0ydw2Df+n7mvoC5W +t6NlUe07qxS/TFED6F+KBZvuim6c779o+sjaC+NCydAXFJy3SuCvkychVSa1ZC+N +8f+mQAWFBVzKBxlcCxMoTFh/wqXvRdpg065lYZ1Tg3TCrvJcwhbtkj6EPnNgiLx2 +9CzP0H1907he0ZESEOnN3col49XtmS++dYFLJPlFRpTJKSFTnCZFqhMX5OfNeOI5 +wSsSnqaeG8XmDtkx2Q== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIF4DCCA8igAwIBAgIRAPL6ZOJ0Y9ON/RAdBB92ylgwDQYJKoZIhvcNAQELBQAw +ZzELMAkGA1UEBhMCY2gxETAPBgNVBAoTCFN3aXNzY29tMSUwIwYDVQQLExxEaWdp +dGFsIENlcnRpZmljYXRlIFNlcnZpY2VzMR4wHAYDVQQDExVTd2lzc2NvbSBSb290 +IEVWIENBIDIwHhcNMTEwNjI0MDk0NTA4WhcNMzEwNjI1MDg0NTA4WjBnMQswCQYD +VQQGEwJjaDERMA8GA1UEChMIU3dpc3Njb20xJTAjBgNVBAsTHERpZ2l0YWwgQ2Vy +dGlmaWNhdGUgU2VydmljZXMxHjAcBgNVBAMTFVN3aXNzY29tIFJvb3QgRVYgQ0Eg +MjCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMT3HS9X6lds93BdY7Bx +UglgRCgzo3pOCvrY6myLURYaVa5UJsTMRQdBTxB5f3HSek4/OE6zAMaVylvNwSqD +1ycfMQ4jFrclyxy0uYAyXhqdk/HoPGAsp15XGVhRXrwsVgu42O+LgrQ8uMIkqBPH +oCE2G3pXKSinLr9xJZDzRINpUKTk4RtiGZQJo/PDvO/0vezbE53PnUgJUmfANykR +HvvSEaeFGHR55E+FFOtSN+KxRdjMDUN/rhPSays/p8LiqG12W0OfvrSdsyaGOx9/ +5fLoZigWJdBLlzin5M8J0TbDC77aO0RYjb7xnglrPvMyxyuHxuxenPaHZa0zKcQv +idm5y8kDnftslFGXEBuGCxobP/YCfnvUxVFkKJ3106yDgYjTdLRZncHrYTNaRdHL +OdAGalNgHa/2+2m8atwBz735j9m9W8E6X47aD0upm50qKGsaCnw8qyIL5XctcfaC +NYGu+HuB5ur+rPQam3Rc6I8k9l2dRsQs0h4rIWqDJ2dVSqTjyDKXZpBy2uPUZC5f +46Fq9mDU5zXNysRojddxyNMkM3OxbPlq4SjbX8Y96L5V5jcb7STZDxmPX2MYWFCB +UWVv8p9+agTnNCRxunZLWB4ZvRVgRaoMEkABnRDixzgHcgplwLa7JSnaFp6LNYth +7eVxV4O1PHGf40+/fh6Bn0GXAgMBAAGjgYYwgYMwDgYDVR0PAQH/BAQDAgGGMB0G +A1UdIQQWMBQwEgYHYIV0AVMCAgYHYIV0AVMCAjASBgNVHRMBAf8ECDAGAQH/AgED +MB0GA1UdDgQWBBRF2aWBbj2ITY1x0kbBbkUe88SAnTAfBgNVHSMEGDAWgBRF2aWB +bj2ITY1x0kbBbkUe88SAnTANBgkqhkiG9w0BAQsFAAOCAgEAlDpzBp9SSzBc1P6x +XCX5145v9Ydkn+0UjrgEjihLj6p7jjm02Vj2e6E1CqGdivdj5eu9OYLU43otb98T +PLr+flaYC/NUn81ETm484T4VvwYmneTwkLbUwp4wLh/vx3rEUMfqe9pQy3omywC0 +Wqu1kx+AiYQElY2NfwmTv9SoqORjbdlk5LgpWgi/UOGED1V7XwgiG/W9mR4U9s70 +WBCCswo9GcG/W6uqmdjyMb3lOGbcWAXH7WMaLgqXfIeTK7KK4/HsGOV1timH59yL +Gn602MnTihdsfSlEvoqq9X46Lmgxk7lq2prg2+kupYTNHAq4Sgj5nPFhJpiTt3tm +7JFe3VE/23MPrQRYCd0EApUKPtN236YQHoA96M2kZNEzx5LH4k5E4wnJTsJdhw4S +nr8PyQUQ3nqjsTzyP6WqJ3mtMX0f/fwZacXduT98zca0wjAefm6S139hdlqP65VN +vBFuIXxZN5nQBrz5Bm0yFqXZaajh3DyAHmBR3NdUIR7KYndP+tiPsys6DXhyyWhB +WkdKwqPrGtcKqzwyVcgKEZzfdNbwQBUdyLmPtTbFr/giuMod89a2GQ+fYWVq6nTI +fI/DT11lgh/ZDYnadXL77/FHZxOzyNEZiCcmmpl5fx7kLD977vHeTYuWl8PVP3wb +I+2ksx0WckNLIOFZfsLorSa/ovc= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDwzCCAqugAwIBAgIBATANBgkqhkiG9w0BAQsFADCBgjELMAkGA1UEBhMCREUx +KzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnByaXNlIFNlcnZpY2VzIEdtYkgxHzAd +BgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50ZXIxJTAjBgNVBAMMHFQtVGVsZVNl +YyBHbG9iYWxSb290IENsYXNzIDIwHhcNMDgxMDAxMTA0MDE0WhcNMzMxMDAxMjM1 +OTU5WjCBgjELMAkGA1UEBhMCREUxKzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnBy +aXNlIFNlcnZpY2VzIEdtYkgxHzAdBgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50 +ZXIxJTAjBgNVBAMMHFQtVGVsZVNlYyBHbG9iYWxSb290IENsYXNzIDIwggEiMA0G +CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCqX9obX+hzkeXaXPSi5kfl82hVYAUd +AqSzm1nzHoqvNK38DcLZSBnuaY/JIPwhqgcZ7bBcrGXHX+0CfHt8LRvWurmAwhiC +FoT6ZrAIxlQjgeTNuUk/9k9uN0goOA/FvudocP05l03Sx5iRUKrERLMjfTlH6VJi +1hKTXrcxlkIF+3anHqP1wvzpesVsqXFP6st4vGCvx9702cu+fjOlbpSD8DT6Iavq +jnKgP6TeMFvvhk1qlVtDRKgQFRzlAVfFmPHmBiiRqiDFt1MmUUOyCxGVWOHAD3bZ +wI18gfNycJ5v/hqO2V81xrJvNHy+SE/iWjnX2J14np+GPgNeGYtEotXHAgMBAAGj +QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBS/ +WSA2AHmgoCJrjNXyYdK4LMuCSjANBgkqhkiG9w0BAQsFAAOCAQEAMQOiYQsfdOhy +NsZt+U2e+iKo4YFWz827n+qrkRk4r6p8FU3ztqONpfSO9kSpp+ghla0+AGIWiPAC +uvxhI+YzmzB6azZie60EI4RYZeLbK4rnJVM3YlNfvNoBYimipidx5joifsFvHZVw +IEoHNN/q/xWA5brXethbdXwFeilHfkCoMRN3zUA7tFFHei4R40cR3p1m0IvVVGb6 +g1XqfMIpiRvpb7PO4gWEyS8+eIVibslfwXhjdFjASBgMmTnrpMwatXlajRWc2BQN +9noHV8cigwUtPJslJj0Ys6lDfMjIq2SPDqO/nBudMNva0Bkuqjzx+zOAduTNrRlP +BSeOE6Fuwg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDwzCCAqugAwIBAgIBATANBgkqhkiG9w0BAQsFADCBgjELMAkGA1UEBhMCREUx +KzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnByaXNlIFNlcnZpY2VzIEdtYkgxHzAd +BgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50ZXIxJTAjBgNVBAMMHFQtVGVsZVNl +YyBHbG9iYWxSb290IENsYXNzIDMwHhcNMDgxMDAxMTAyOTU2WhcNMzMxMDAxMjM1 +OTU5WjCBgjELMAkGA1UEBhMCREUxKzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnBy +aXNlIFNlcnZpY2VzIEdtYkgxHzAdBgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50 +ZXIxJTAjBgNVBAMMHFQtVGVsZVNlYyBHbG9iYWxSb290IENsYXNzIDMwggEiMA0G +CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC9dZPwYiJvJK7genasfb3ZJNW4t/zN +8ELg63iIVl6bmlQdTQyK9tPPcPRStdiTBONGhnFBSivwKixVA9ZIw+A5OO3yXDw/ +RLyTPWGrTs0NvvAgJ1gORH8EGoel15YUNpDQSXuhdfsaa3Ox+M6pCSzyU9XDFES4 +hqX2iys52qMzVNn6chr3IhUciJFrf2blw2qAsCTz34ZFiP0Zf3WHHx+xGwpzJFu5 +ZeAsVMhg02YXP+HMVDNzkQI6pn97djmiH5a2OK61yJN0HZ65tOVgnS9W0eDrXltM +EnAMbEQgqxHY9Bn20pxSN+f6tsIxO0rUFJmtxxr1XV/6B7h8DR/Wgx6zAgMBAAGj +QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBS1 +A/d2O2GCahKqGFPrAyGUv/7OyjANBgkqhkiG9w0BAQsFAAOCAQEAVj3vlNW92nOy +WL6ukK2YJ5f+AbGwUgC4TeQbIXQbfsDuXmkqJa9c1h3a0nnJ85cp4IaH3gRZD/FZ +1GSFS5mvJQQeyUapl96Cshtwn5z2r3Ex3XsFpSzTucpH9sry9uetuUg/vBa3wW30 +6gmv7PO15wWeph6KU1HWk4HMdJP2udqmJQV0eVp+QD6CSyYRMG7hP0HHRwA11fXT +91Q+gT3aSWqas+8QPebrb9HIIkfLzM8BMZLZGOMivgkeGj5asuRrDFR6fUNOuIml +e9eiPZaGzPImNC1qkp2aGtAw4l1OBLBfiyB+d8E9lYLRRpo7PHi4b6HQDWSieB4p +TpPDpFQUWw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEqjCCA5KgAwIBAgIOLmoAAQACH9dSISwRXDswDQYJKoZIhvcNAQEFBQAwdjEL +MAkGA1UEBhMCREUxHDAaBgNVBAoTE1RDIFRydXN0Q2VudGVyIEdtYkgxIjAgBgNV +BAsTGVRDIFRydXN0Q2VudGVyIENsYXNzIDIgQ0ExJTAjBgNVBAMTHFRDIFRydXN0 +Q2VudGVyIENsYXNzIDIgQ0EgSUkwHhcNMDYwMTEyMTQzODQzWhcNMjUxMjMxMjI1 +OTU5WjB2MQswCQYDVQQGEwJERTEcMBoGA1UEChMTVEMgVHJ1c3RDZW50ZXIgR21i +SDEiMCAGA1UECxMZVEMgVHJ1c3RDZW50ZXIgQ2xhc3MgMiBDQTElMCMGA1UEAxMc +VEMgVHJ1c3RDZW50ZXIgQ2xhc3MgMiBDQSBJSTCCASIwDQYJKoZIhvcNAQEBBQAD +ggEPADCCAQoCggEBAKuAh5uO8MN8h9foJIIRszzdQ2Lu+MNF2ujhoF/RKrLqk2jf +tMjWQ+nEdVl//OEd+DFwIxuInie5e/060smp6RQvkL4DUsFJzfb95AhmC1eKokKg +uNV/aVyQMrKXDcpK3EY+AlWJU+MaWss2xgdW94zPEfRMuzBwBJWl9jmM/XOBCH2J +XjIeIqkiRUuwZi4wzJ9l/fzLganx4Duvo4bRierERXlQXa7pIXSSTYtZgo+U4+lK +8edJsBTj9WLL1XK9H7nSn6DNqPoByNkN39r8R52zyFTfSUrxIan+GE7uSNQZu+99 +5OKdy1u2bv/jzVrndIIFuoAlOMvkaZ6vQaoahPUCAwEAAaOCATQwggEwMA8GA1Ud +EwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBTjq1RMgKHbVkO3 +kUrL84J6E1wIqzCB7QYDVR0fBIHlMIHiMIHfoIHcoIHZhjVodHRwOi8vd3d3LnRy +dXN0Y2VudGVyLmRlL2NybC92Mi90Y19jbGFzc18yX2NhX0lJLmNybIaBn2xkYXA6 +Ly93d3cudHJ1c3RjZW50ZXIuZGUvQ049VEMlMjBUcnVzdENlbnRlciUyMENsYXNz +JTIwMiUyMENBJTIwSUksTz1UQyUyMFRydXN0Q2VudGVyJTIwR21iSCxPVT1yb290 +Y2VydHMsREM9dHJ1c3RjZW50ZXIsREM9ZGU/Y2VydGlmaWNhdGVSZXZvY2F0aW9u +TGlzdD9iYXNlPzANBgkqhkiG9w0BAQUFAAOCAQEAjNfffu4bgBCzg/XbEeprS6iS +GNn3Bzn1LL4GdXpoUxUc6krtXvwjshOg0wn/9vYua0Fxec3ibf2uWWuFHbhOIprt +ZjluS5TmVfwLG4t3wVMTZonZKNaL80VKY7f9ewthXbhtvsPcW3nS7Yblok2+XnR8 +au0WOB9/WIFaGusyiC2y8zl3gK9etmF1KdsjTYjKUCjLhdLTEKJZbtOTVAB6okaV +hgWcqRmY5TFyDADiZ9lA4CQze28suVyrZZ0srHbqNZn1l7kPJOzHdiEoZa5X6AeI +dUpWoNIFOqTmjZKILPPy4cHGYdtBxceb9w4aUUXCYWvcZCcXjFq32nQozZfkvQ== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIID3TCCAsWgAwIBAgIOHaIAAQAC7LdggHiNtgYwDQYJKoZIhvcNAQEFBQAweTEL +MAkGA1UEBhMCREUxHDAaBgNVBAoTE1RDIFRydXN0Q2VudGVyIEdtYkgxJDAiBgNV +BAsTG1RDIFRydXN0Q2VudGVyIFVuaXZlcnNhbCBDQTEmMCQGA1UEAxMdVEMgVHJ1 +c3RDZW50ZXIgVW5pdmVyc2FsIENBIEkwHhcNMDYwMzIyMTU1NDI4WhcNMjUxMjMx +MjI1OTU5WjB5MQswCQYDVQQGEwJERTEcMBoGA1UEChMTVEMgVHJ1c3RDZW50ZXIg +R21iSDEkMCIGA1UECxMbVEMgVHJ1c3RDZW50ZXIgVW5pdmVyc2FsIENBMSYwJAYD +VQQDEx1UQyBUcnVzdENlbnRlciBVbml2ZXJzYWwgQ0EgSTCCASIwDQYJKoZIhvcN +AQEBBQADggEPADCCAQoCggEBAKR3I5ZEr5D0MacQ9CaHnPM42Q9e3s9B6DGtxnSR +JJZ4Hgmgm5qVSkr1YnwCqMqs+1oEdjneX/H5s7/zA1hV0qq34wQi0fiU2iIIAI3T +fCZdzHd55yx4Oagmcw6iXSVphU9VDprvxrlE4Vc93x9UIuVvZaozhDrzznq+VZeu +jRIPFDPiUHDDSYcTvFHe15gSWu86gzOSBnWLknwSaHtwag+1m7Z3W0hZneTvWq3z +wZ7U10VOylY0Ibw+F1tvdwxIAUMpsN0/lm7mlaoMwCC2/T42J5zjXM9OgdwZu5GQ +fezmlwQek8wiSdeXhrYTCjxDI3d+8NzmzSQfO4ObNDqDNOMCAwEAAaNjMGEwHwYD +VR0jBBgwFoAUkqR1LKSevoFE63n8isWVpesQdXMwDwYDVR0TAQH/BAUwAwEB/zAO +BgNVHQ8BAf8EBAMCAYYwHQYDVR0OBBYEFJKkdSyknr6BROt5/IrFlaXrEHVzMA0G +CSqGSIb3DQEBBQUAA4IBAQAo0uCG1eb4e/CX3CJrO5UUVg8RMKWaTzqwOuAGy2X1 +7caXJ/4l8lfmXpWMPmRgFVp/Lw0BxbFg/UU1z/CyvwbZ71q+s2IhtNerNXxTPqYn +8aEt2hojnczd7Dwtnic0XQ/CNnm8yUpiLe1r2X1BQ3y2qsrtYbE3ghUJGooWMNjs +ydZHcnhLEEYUjl8Or+zHL6sQ17bxbuyGssLoDZJz3KL0Dzq/YSMQiZxIQG5wALPT +ujdEWBF6AmqI8Dc08BnprNRlc/ZpjGSUOnmFKbAWKwyCPwacx/0QK54PLLae4xW/ +2TYcuiUaUj0a7CIMHOCkoj3w6DnPgcB77V0fb8XQC9eY +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIID+zCCAuOgAwIBAgIBATANBgkqhkiG9w0BAQUFADCBtzE/MD0GA1UEAww2VMOc +UktUUlVTVCBFbGVrdHJvbmlrIFNlcnRpZmlrYSBIaXptZXQgU2HEn2xhecSxY8Sx +c8SxMQswCQYDVQQGDAJUUjEPMA0GA1UEBwwGQU5LQVJBMVYwVAYDVQQKDE0oYykg +MjAwNSBUw5xSS1RSVVNUIEJpbGdpIMSwbGV0acWfaW0gdmUgQmlsacWfaW0gR8O8 +dmVubGnEn2kgSGl6bWV0bGVyaSBBLsWeLjAeFw0wNTA1MTMxMDI3MTdaFw0xNTAz +MjIxMDI3MTdaMIG3MT8wPQYDVQQDDDZUw5xSS1RSVVNUIEVsZWt0cm9uaWsgU2Vy +dGlmaWthIEhpem1ldCBTYcSfbGF5xLFjxLFzxLExCzAJBgNVBAYMAlRSMQ8wDQYD +VQQHDAZBTktBUkExVjBUBgNVBAoMTShjKSAyMDA1IFTDnFJLVFJVU1QgQmlsZ2kg +xLBsZXRpxZ9pbSB2ZSBCaWxpxZ9pbSBHw7x2ZW5sacSfaSBIaXptZXRsZXJpIEEu +xZ4uMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAylIF1mMD2Bxf3dJ7 +XfIMYGFbazt0K3gNfUW9InTojAPBxhEqPZW8qZSwu5GXyGl8hMW0kWxsE2qkVa2k +heiVfrMArwDCBRj1cJ02i67L5BuBf5OI+2pVu32Fks66WJ/bMsW9Xe8iSi9BB35J +YbOG7E6mQW6EvAPs9TscyB/C7qju6hJKjRTP8wrgUDn5CDX4EVmt5yLqS8oUBt5C +urKZ8y1UiBAG6uEaPj1nH/vO+3yC6BFdSsG5FOpU2WabfIl9BJpiyelSPJ6c79L1 +JuTm5Rh8i27fbMx4W09ysstcP4wFjdFMjK2Sx+F4f2VsSQZQLJ4ywtdKxnWKWU51 +b0dewQIDAQABoxAwDjAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBBQUAA4IBAQAV +9VX/N5aAWSGk/KEVTCD21F/aAyT8z5Aa9CEKmu46sWrv7/hg0Uw2ZkUd82YCdAR7 +kjCo3gp2D++Vbr3JN+YaDayJSFvMgzbC9UZcWYJWtNX+I7TYVBxEq8Sn5RTOPEFh +fEPmzcSBCYsk+1Ql1haolgxnB2+zUEfjHCQo3SqYpGH+2+oSN7wBGjSFvW5P55Fy +B0SFHljKVETd96y5y4khctuPwGkplyqjrhgjlxxBKot8KsF8kOipKMDTkcatKIdA +aLX/7KfS0zgYnNN9aV3wxqUeJBujR/xpB2jn5Jq07Q+hh4cCzofSSE7hvP/L8XKS +RGQDJereW26fyfJOrN3H +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEPTCCAyWgAwIBAgIBATANBgkqhkiG9w0BAQUFADCBvzE/MD0GA1UEAww2VMOc +UktUUlVTVCBFbGVrdHJvbmlrIFNlcnRpZmlrYSBIaXptZXQgU2HEn2xhecSxY8Sx +c8SxMQswCQYDVQQGEwJUUjEPMA0GA1UEBwwGQW5rYXJhMV4wXAYDVQQKDFVUw5xS +S1RSVVNUIEJpbGdpIMSwbGV0acWfaW0gdmUgQmlsacWfaW0gR8O8dmVubGnEn2kg +SGl6bWV0bGVyaSBBLsWeLiAoYykgQXJhbMSxayAyMDA3MB4XDTA3MTIyNTE4Mzcx +OVoXDTE3MTIyMjE4MzcxOVowgb8xPzA9BgNVBAMMNlTDnFJLVFJVU1QgRWxla3Ry +b25payBTZXJ0aWZpa2EgSGl6bWV0IFNhxJ9sYXnEsWPEsXPEsTELMAkGA1UEBhMC +VFIxDzANBgNVBAcMBkFua2FyYTFeMFwGA1UECgxVVMOcUktUUlVTVCBCaWxnaSDE +sGxldGnFn2ltIHZlIEJpbGnFn2ltIEfDvHZlbmxpxJ9pIEhpem1ldGxlcmkgQS7F +ni4gKGMpIEFyYWzEsWsgMjAwNzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC +ggEBAKu3PgqMyKVYFeaK7yc9SrToJdPNM8Ig3BnuiD9NYvDdE3ePYakqtdTyuTFY +KTsvP2qcb3N2Je40IIDu6rfwxArNK4aUyeNgsURSsloptJGXg9i3phQvKUmi8wUG ++7RP2qFsmmaf8EMJyupyj+sA1zU511YXRxcw9L6/P8JorzZAwan0qafoEGsIiveG +HtyaKhUG9qPw9ODHFNRRf8+0222vR5YXm3dx2KdxnSQM9pQ/hTEST7ruToK4uT6P +IzdezKKqdfcYbwnTrqdUKDT74eA7YH2gvnmJhsifLfkKS8RQouf9eRbHegsYz85M +733WB2+Y8a+xwXrXgTW4qhe04MsCAwEAAaNCMEAwHQYDVR0OBBYEFCnFkKslrxHk +Yb+j/4hhkeYO/pyBMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MA0G +CSqGSIb3DQEBBQUAA4IBAQAQDdr4Ouwo0RSVgrESLFF6QSU2TJ/sPx+EnWVUXKgW +AkD6bho3hO9ynYYKVZ1WKKxmLNA6VpM0ByWtCLCPyA8JWcqdmBzlVPi5RX9ql2+I +aE1KBiY3iAIOtsbWcpnOa3faYjGkVh+uX4132l32iPwa2Z61gfAyuOOI0JzzaqC5 +mxRZNTZPz/OOXl0XrRWV2N2y1RVuAE6zS89mlOTgzbUF2mNXi+WzqtvALhyQRNsa +XRik7r4EW5nVcV9VZWRi1aKbBFmGyGJ353yCRWo9F7/snXUMrqNvWtMvmDb08PUZ +qxFdyKbjKlhqQgnDvZImZjINXQhVdP+MmNAKpoRq0Tl9 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEPDCCAySgAwIBAgIBATANBgkqhkiG9w0BAQUFADCBvjE/MD0GA1UEAww2VMOc +UktUUlVTVCBFbGVrdHJvbmlrIFNlcnRpZmlrYSBIaXptZXQgU2HEn2xhecSxY8Sx +c8SxMQswCQYDVQQGEwJUUjEPMA0GA1UEBwwGQW5rYXJhMV0wWwYDVQQKDFRUw5xS +S1RSVVNUIEJpbGdpIMSwbGV0acWfaW0gdmUgQmlsacWfaW0gR8O8dmVubGnEn2kg +SGl6bWV0bGVyaSBBLsWeLiAoYykgS2FzxLFtIDIwMDUwHhcNMDUxMTA3MTAwNzU3 +WhcNMTUwOTE2MTAwNzU3WjCBvjE/MD0GA1UEAww2VMOcUktUUlVTVCBFbGVrdHJv +bmlrIFNlcnRpZmlrYSBIaXptZXQgU2HEn2xhecSxY8Sxc8SxMQswCQYDVQQGEwJU +UjEPMA0GA1UEBwwGQW5rYXJhMV0wWwYDVQQKDFRUw5xSS1RSVVNUIEJpbGdpIMSw +bGV0acWfaW0gdmUgQmlsacWfaW0gR8O8dmVubGnEn2kgSGl6bWV0bGVyaSBBLsWe +LiAoYykgS2FzxLFtIDIwMDUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB +AQCpNn7DkUNMwxmYCMjHWHtPFoylzkkBH3MOrHUTpvqeLCDe2JAOCtFp0if7qnef +J1Il4std2NiDUBd9irWCPwSOtNXwSadktx4uXyCcUHVPr+G1QRT0mJKIx+XlZEdh +R3n9wFHxwZnn3M5q+6+1ATDcRhzviuyV79z/rxAc653YsKpqhRgNF8k+v/Gb0AmJ +Qv2gQrSdiVFVKc8bcLyEVK3BEx+Y9C52YItdP5qtygy/p1Zbj3e41Z55SZI/4PGX +JHpsmxcPbe9TmJEr5A++WXkHeLuXlfSfadRYhwqp48y2WBmfJiGxxFmNskF1wK1p +zpwACPI2/z7woQ8arBT9pmAPAgMBAAGjQzBBMB0GA1UdDgQWBBTZN7NOBf3Zz58S +Fq62iS/rJTqIHDAPBgNVHQ8BAf8EBQMDBwYAMA8GA1UdEwEB/wQFMAMBAf8wDQYJ +KoZIhvcNAQEFBQADggEBAHJglrfJ3NgpXiOFX7KzLXb7iNcX/nttRbj2hWyfIvwq +ECLsqrkw9qtY1jkQMZkpAL2JZkH7dN6RwRgLn7Vhy506vvWolKMiVW4XSf/SKfE4 +Jl3vpao6+XF75tpYHdN0wgH6PmlYX63LaL4ULptswLbcoCb6dxriJNoaN+BnrdFz +gw2lGh1uEpJ+hGIAF728JRhX8tepb1mIvDS3LoV4nZbcFMMsilKbloxSZj2GFotH +uFEJjOp9zYhys2AzsfAKRO8P9Qk3iCQOLGsgOqL6EfJANZxEaGM7rDNvY7wsu/LS +y3Z9fYjYHcgFHW68lKlmjHdxx/qR+i9Rnuk5UrbnBEI= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFQTCCAymgAwIBAgICDL4wDQYJKoZIhvcNAQELBQAwUTELMAkGA1UEBhMCVFcx +EjAQBgNVBAoTCVRBSVdBTi1DQTEQMA4GA1UECxMHUm9vdCBDQTEcMBoGA1UEAxMT +VFdDQSBHbG9iYWwgUm9vdCBDQTAeFw0xMjA2MjcwNjI4MzNaFw0zMDEyMzExNTU5 +NTlaMFExCzAJBgNVBAYTAlRXMRIwEAYDVQQKEwlUQUlXQU4tQ0ExEDAOBgNVBAsT +B1Jvb3QgQ0ExHDAaBgNVBAMTE1RXQ0EgR2xvYmFsIFJvb3QgQ0EwggIiMA0GCSqG +SIb3DQEBAQUAA4ICDwAwggIKAoICAQCwBdvI64zEbooh745NnHEKH1Jw7W2CnJfF +10xORUnLQEK1EjRsGcJ0pDFfhQKX7EMzClPSnIyOt7h52yvVavKOZsTuKwEHktSz +0ALfUPZVr2YOy+BHYC8rMjk1Ujoog/h7FsYYuGLWRyWRzvAZEk2tY/XTP3VfKfCh +MBwqoJimFb3u/Rk28OKRQ4/6ytYQJ0lM793B8YVwm8rqqFpD/G2Gb3PpN0Wp8DbH +zIh1HrtsBv+baz4X7GGqcXzGHaL3SekVtTzWoWH1EfcFbx39Eb7QMAfCKbAJTibc +46KokWofwpFFiFzlmLhxpRUZyXx1EcxwdE8tmx2RRP1WKKD+u4ZqyPpcC1jcxkt2 +yKsi2XMPpfRaAok/T54igu6idFMqPVMnaR1sjjIsZAAmY2E2TqNGtz99sy2sbZCi +laLOz9qC5wc0GZbpuCGqKX6mOL6OKUohZnkfs8O1CWfe1tQHRvMq2uYiN2DLgbYP +oA/pyJV/v1WRBXrPPRXAb94JlAGD1zQbzECl8LibZ9WYkTunhHiVJqRaCPgrdLQA +BDzfuBSO6N+pjWxnkjMdwLfS7JLIvgm/LCkFbwJrnu+8vyq8W8BQj0FwcYeyTbcE +qYSjMq+u7msXi7Kx/mzhkIyIqJdIzshNy/MGz19qCkKxHh53L46g5pIOBvwFItIm +4TFRfTLcDwIDAQABoyMwITAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB +/zANBgkqhkiG9w0BAQsFAAOCAgEAXzSBdu+WHdXltdkCY4QWwa6gcFGn90xHNcgL +1yg9iXHZqjNB6hQbbCEAwGxCGX6faVsgQt+i0trEfJdLjbDorMjupWkEmQqSpqsn +LhpNgb+E1HAerUf+/UqdM+DyucRFCCEK2mlpc3INvjT+lIutwx4116KD7+U4x6WF +H6vPNOw/KP4M8VeGTslV9xzU2KV9Bnpv1d8Q34FOIWWxtuEXeZVFBs5fzNxGiWNo +RI2T9GRwoD2dKAXDOXC4Ynsg/eTb6QihuJ49CcdP+yz4k3ZB3lLg4VfSnQO8d57+ +nile98FRYB/e2guyLXW3Q0iT5/Z5xoRdgFlglPx4mI88k1HtQJAH32RjJMtOcQWh +15QaiDLxInQirqWm2BJpTGCjAu4r7NRjkgtevi92a6O2JryPA9gK8kxkRr05YuWW +6zRjESjMlfGt7+/cgFhI6Uu46mWs6fyAtbXIRfmswZ/ZuepiiI7E8UuDEq3mi4TW +nsLrgxifarsbJGAzcMzs9zLzXNl5fe+epP7JI8Mk7hWSsT2RTyaGvWZzJBPqpK5j +wa19hAM8EHiGG3njxPPyBJUgriOCxLM6AGK/5jYk4Ve6xx6QddVfP5VhK8E7zeWz +aGHQRiapIVJpLesux+t3zqY6tQMzT3bR51xUAV3LePTJDL/PEo4XLSNolOer/qmy +KwbQBM0= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDezCCAmOgAwIBAgIBATANBgkqhkiG9w0BAQUFADBfMQswCQYDVQQGEwJUVzES +MBAGA1UECgwJVEFJV0FOLUNBMRAwDgYDVQQLDAdSb290IENBMSowKAYDVQQDDCFU +V0NBIFJvb3QgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDgwODI4MDcyNDMz +WhcNMzAxMjMxMTU1OTU5WjBfMQswCQYDVQQGEwJUVzESMBAGA1UECgwJVEFJV0FO +LUNBMRAwDgYDVQQLDAdSb290IENBMSowKAYDVQQDDCFUV0NBIFJvb3QgQ2VydGlm +aWNhdGlvbiBBdXRob3JpdHkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB +AQCwfnK4pAOU5qfeCTiRShFAh6d8WWQUe7UREN3+v9XAu1bihSX0NXIP+FPQQeFE +AcK0HMMxQhZHhTMidrIKbw/lJVBPhYa+v5guEGcevhEFhgWQxFnQfHgQsIBct+HH +K3XLfJ+utdGdIzdjp9xCoi2SBBtQwXu4PhvJVgSLL1KbralW6cH/ralYhzC2gfeX +RfwZVzsrb+RH9JlF/h3x+JejiB03HFyP4HYlmlD4oFT/RJB2I9IyxsOrBr/8+7/z +rX2SYgJbKdM1o5OaQ2RgXbL6Mv87BK9NQGr5x+PvI/1ry+UPizgN7gr8/g+YnzAx +3WxSZfmLgb4i4RxYA7qRG4kHAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV +HRMBAf8EBTADAQH/MB0GA1UdDgQWBBRqOFsmjd6LWvJPelSDGRjjCDWmujANBgkq +hkiG9w0BAQUFAAOCAQEAPNV3PdrfibqHDAhUaiBQkr6wQT25JmSDCi/oQMCXKCeC +MErJk/9q56YAf4lCmtYR5VPOL8zy2gXE/uJQxDqGfczafhAJO5I1KlOy/usrBdls +XebQ79NqZp4VKIV66IIArB6nCWlWQtNoURi+VJq/REG6Sb4gumlc7rh3zc5sH62D +lhh9DrUUOYTxKOkto557HnpyWoOzeW/vtPzQCqVYT0bf+215WfKEIlKuD8z7fDvn +aspHYcN6+NOSBB+4IIThNlQWx0DeO4pz3N/GCUzf7Nr/1FNCocnyYh0igzyXxfkZ +YiesZSLX0zzG5Y6yU8xJzrww/nsOM5D77dIUkR8Hrw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFcjCCA1qgAwIBAgIQH51ZWtcvwgZEpYAIaeNe9jANBgkqhkiG9w0BAQUFADA/ +MQswCQYDVQQGEwJUVzEwMC4GA1UECgwnR292ZXJubWVudCBSb290IENlcnRpZmlj +YXRpb24gQXV0aG9yaXR5MB4XDTAyMTIwNTEzMjMzM1oXDTMyMTIwNTEzMjMzM1ow +PzELMAkGA1UEBhMCVFcxMDAuBgNVBAoMJ0dvdmVybm1lbnQgUm9vdCBDZXJ0aWZp +Y2F0aW9uIEF1dGhvcml0eTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIB +AJoluOzMonWoe/fOW1mKydGGEghU7Jzy50b2iPN86aXfTEc2pBsBHH8eV4qNw8XR +IePaJD9IK/ufLqGU5ywck9G/GwGHU5nOp/UKIXZ3/6m3xnOUT0b3EEk3+qhZSV1q +gQdW8or5BtD3cCJNtLdBuTK4sfCxw5w/cP1T3YGq2GN49thTbqGsaoQkclSGxtKy +yhwOeYHWtXBiCAEuTk8O1RGvqa/lmr/czIdtJuTJV6L7lvnM4T9TjGxMfptTCAts +F/tnyMKtsc2AtJfcdgEWFelq16TheEfOhtX7MfP6Mb40qij7cEwdScevLJ1tZqa2 +jWR+tSBqnTuBto9AAGdLiYa4zGX+FVPpBMHWXx1E1wovJ5pGfaENda1UhhXcSTvx +ls4Pm6Dso3pdvtUqdULle96ltqqvKKyskKw4t9VoNSZ63Pc78/1Fm9G7Q3hub/FC +VGqY8A2tl+lSXunVanLeavcbYBT0peS2cWeqH+riTcFCQP5nRhc4L0c/cZyu5SHK +YS1tB6iEfC3uUSXxY5Ce/eFXiGvviiNtsea9P63RPZYLhY3Naye7twWb7LuRqQoH +EgKXTiCQ8P8NHuJBO9NAOueNXdpm5AKwB1KYXA6OM5zCppX7VRluTI6uSw+9wThN +Xo+EHWbNxWCWtFJaBYmOlXqYwZE8lSOyDvR5tMl8wUohAgMBAAGjajBoMB0GA1Ud +DgQWBBTMzO/MKWCkO7GStjz6MmKPrCUVOzAMBgNVHRMEBTADAQH/MDkGBGcqBwAE +MTAvMC0CAQAwCQYFKw4DAhoFADAHBgVnKgMAAAQUA5vwIhP/lSg209yewDL7MTqK +UWUwDQYJKoZIhvcNAQEFBQADggIBAECASvomyc5eMN1PhnR2WPWus4MzeKR6dBcZ +TulStbngCnRiqmjKeKBMmo4sIy7VahIkv9Ro04rQ2JyftB8M3jh+Vzj8jeJPXgyf +qzvS/3WXy6TjZwj/5cAWtUgBfen5Cv8b5Wppv3ghqMKnI6mGq3ZW6A4M9hPdKmaK +ZEk9GhiHkASfQlK3T8v+R0F2Ne//AHY2RTKbxkaFXeIksB7jSJaYV0eUVXoPQbFE +JPPB/hprv4j9wabak2BegUqZIJxIZhm1AHlUD7gsL0u8qV1bYH+Mh6XgUmMqvtg7 +hUAV/h62ZT/FS9p+tXo1KaMuephgIqP0fSdOLeq0dDzpD6QzDxARvBMB1uUO07+1 +EqLhRSPAzAhuYbeJq4PjJB7mXQfnHyA+z2fI56wwbSdLaG5LKlwCCDTb+HbkZ6Mm +nD+iMsJKxYEYMRBWqoTvLQr/uB930r+lWKBi5NdLkXWNiYCYfm3LU05er/ayl4WX +udpVBrkk7tfGOB5jGxI7leFYrPLfhNVfmS8NVVvmONsuP3LpSIXLuykTjx44Vbnz +ssQwmSNOXfJIoRIM3BKQCZBUkQM8R+XVyWXgt0t97EfTsws+rZ7QdAAO671RrcDe +LMDDav7v3Aun+kbfYNucpllQdSNpc5Oy+fwC00fmcc4QAu4njIT/rEUNE1yDMuAl +pYYsfPQS +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFODCCAyCgAwIBAgIRAJW+FqD3LkbxezmCcvqLzZYwDQYJKoZIhvcNAQEFBQAw +NzEUMBIGA1UECgwLVGVsaWFTb25lcmExHzAdBgNVBAMMFlRlbGlhU29uZXJhIFJv +b3QgQ0EgdjEwHhcNMDcxMDE4MTIwMDUwWhcNMzIxMDE4MTIwMDUwWjA3MRQwEgYD +VQQKDAtUZWxpYVNvbmVyYTEfMB0GA1UEAwwWVGVsaWFTb25lcmEgUm9vdCBDQSB2 +MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMK+6yfwIaPzaSZVfp3F +VRaRXP3vIb9TgHot0pGMYzHw7CTww6XScnwQbfQ3t+XmfHnqjLWCi65ItqwA3GV1 +7CpNX8GH9SBlK4GoRz6JI5UwFpB/6FcHSOcZrr9FZ7E3GwYq/t75rH2D+1665I+X +Z75Ljo1kB1c4VWk0Nj0TSO9P4tNmHqTPGrdeNjPUtAa9GAH9d4RQAEX1jF3oI7x+ +/jXh7VB7qTCNGdMJjmhnXb88lxhTuylixcpecsHHltTbLaC0H2kD7OriUPEMPPCs +81Mt8Bz17Ww5OXOAFshSsCPN4D7c3TxHoLs1iuKYaIu+5b9y7tL6pe0S7fyYGKkm +dtwoSxAgHNN/Fnct7W+A90m7UwW7XWjH1Mh1Fj+JWov3F0fUTPHSiXk+TT2YqGHe +Oh7S+F4D4MHJHIzTjU3TlTazN19jY5szFPAtJmtTfImMMsJu7D0hADnJoWjiUIMu +sDor8zagrC/kb2HCUQk5PotTubtn2txTuXZZNp1D5SDgPTJghSJRt8czu90VL6R4 +pgd7gUY2BIbdeTXHlSw7sKMXNeVzH7RcWe/a6hBle3rQf5+ztCo3O3CLm1u5K7fs +slESl1MpWtTwEhDcTwK7EpIvYtQ/aUN8Ddb8WHUBiJ1YFkveupD/RwGJBmr2X7KQ +arMCpgKIv7NHfirZ1fpoeDVNAgMBAAGjPzA9MA8GA1UdEwEB/wQFMAMBAf8wCwYD +VR0PBAQDAgEGMB0GA1UdDgQWBBTwj1k4ALP1j5qWDNXr+nuqF+gTEjANBgkqhkiG +9w0BAQUFAAOCAgEAvuRcYk4k9AwI//DTDGjkk0kiP0Qnb7tt3oNmzqjMDfz1mgbl +dxSR651Be5kqhOX//CHBXfDkH1e3damhXwIm/9fH907eT/j3HEbAek9ALCI18Bmx +0GtnLLCo4MBANzX2hFxc469CeP6nyQ1Q6g2EdvZR74NTxnr/DlZJLo961gzmJ1Tj +TQpgcmLNkQfWpb/ImWvtxBnmq0wROMVvMeJuScg/doAmAyYp4Db29iBT4xdwNBed +Y2gea+zDTYa4EzAvXUYNR0PVG6pZDrlcjQZIrXSHX8f8MVRBE+LHIQ6e4B4N4cB7 +Q4WQxYpYxmUKeFfyxiMPAdkgS94P+5KFdSpcc41teyWRyu5FrgZLAMzTsVlQ2jqI +OylDRl6XK1TOU2+NSueW+r9xDkKLfP0ooNBIytrEgUy7onOTJsjrDNYmiLbAJM+7 +vVvrdX3pCI6GMyx5dwlppYn8s3CQh3aP0yK7Qs69cwsgJirQmz1wHiRszYd2qReW +t88NkvuOGKmYSdGe/mBEciG5Ge3C9THxOUiIkCR1VBatzvT4aRRkOfujuLpwQMcn +HL/EVlP6Y2XQ8xwOFvVrhlhNGNTkDY6lnVuR3HYkUD/GKvvZt5y11ubQ2egZixVx +SK236thZiNSQvxaz2emsWWFUyBy6ysHK4bkgTI86k4mloMy/0/Z1pHWWbVY= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDJzCCApCgAwIBAgIBATANBgkqhkiG9w0BAQQFADCBzjELMAkGA1UEBhMCWkEx +FTATBgNVBAgTDFdlc3Rlcm4gQ2FwZTESMBAGA1UEBxMJQ2FwZSBUb3duMR0wGwYD +VQQKExRUaGF3dGUgQ29uc3VsdGluZyBjYzEoMCYGA1UECxMfQ2VydGlmaWNhdGlv +biBTZXJ2aWNlcyBEaXZpc2lvbjEhMB8GA1UEAxMYVGhhd3RlIFByZW1pdW0gU2Vy +dmVyIENBMSgwJgYJKoZIhvcNAQkBFhlwcmVtaXVtLXNlcnZlckB0aGF3dGUuY29t +MB4XDTk2MDgwMTAwMDAwMFoXDTIwMTIzMTIzNTk1OVowgc4xCzAJBgNVBAYTAlpB +MRUwEwYDVQQIEwxXZXN0ZXJuIENhcGUxEjAQBgNVBAcTCUNhcGUgVG93bjEdMBsG +A1UEChMUVGhhd3RlIENvbnN1bHRpbmcgY2MxKDAmBgNVBAsTH0NlcnRpZmljYXRp +b24gU2VydmljZXMgRGl2aXNpb24xITAfBgNVBAMTGFRoYXd0ZSBQcmVtaXVtIFNl +cnZlciBDQTEoMCYGCSqGSIb3DQEJARYZcHJlbWl1bS1zZXJ2ZXJAdGhhd3RlLmNv +bTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA0jY2aovXwlue2oFBYo847kkE +VdbQ7xwblRZH7xhINTpS9CtqBo87L+pW46+GjZ4X9560ZXUCTe/LCaIhUdib0GfQ +ug2SBhRz1JPLlyoAnFxODLz6FVL88kRu2hFKbgifLy3j+ao6hnO2RlNYyIkFvYMR +uHM/qgeN9EJN50CdHDcCAwEAAaMTMBEwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG +9w0BAQQFAAOBgQAmSCwWwlj66BZ0DKqqX1Q/8tfJeGBeXm43YyJ3Nn6yF8Q0ufUI +hfzJATj/Tb7yFkJD57taRvvBxhEf8UqwKEbJw8RCfbz6q1lu1bdRiBHjpIUZa4JM +pAwSremkrj/xw0llmozFyD4lt5SZu5IycQfwhl7tUCemDaYj+bvLpgcUQg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDEzCCAnygAwIBAgIBATANBgkqhkiG9w0BAQQFADCBxDELMAkGA1UEBhMCWkEx +FTATBgNVBAgTDFdlc3Rlcm4gQ2FwZTESMBAGA1UEBxMJQ2FwZSBUb3duMR0wGwYD +VQQKExRUaGF3dGUgQ29uc3VsdGluZyBjYzEoMCYGA1UECxMfQ2VydGlmaWNhdGlv +biBTZXJ2aWNlcyBEaXZpc2lvbjEZMBcGA1UEAxMQVGhhd3RlIFNlcnZlciBDQTEm +MCQGCSqGSIb3DQEJARYXc2VydmVyLWNlcnRzQHRoYXd0ZS5jb20wHhcNOTYwODAx +MDAwMDAwWhcNMjAxMjMxMjM1OTU5WjCBxDELMAkGA1UEBhMCWkExFTATBgNVBAgT +DFdlc3Rlcm4gQ2FwZTESMBAGA1UEBxMJQ2FwZSBUb3duMR0wGwYDVQQKExRUaGF3 +dGUgQ29uc3VsdGluZyBjYzEoMCYGA1UECxMfQ2VydGlmaWNhdGlvbiBTZXJ2aWNl +cyBEaXZpc2lvbjEZMBcGA1UEAxMQVGhhd3RlIFNlcnZlciBDQTEmMCQGCSqGSIb3 +DQEJARYXc2VydmVyLWNlcnRzQHRoYXd0ZS5jb20wgZ8wDQYJKoZIhvcNAQEBBQAD +gY0AMIGJAoGBANOkUG7I/1Zr5s9dtuoMaHVHoqrC2oQl/Kj0R1HahbUgdJSGHg91 +yekIYfUGbTBuFRkC6VLAYttNmZ7iagxEOM3+vuNkCXDF/rFrKbYvScg71CcEJRCX +L+eQbcAoQpnXTEPew/UhbVSfXcNY4cDk2VuwuNy0e982OsK1ZiIS1ocNAgMBAAGj +EzARMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEEBQADgYEAB/pMaVz7lcxG +7oWDTSEwjsrZqG9JGubaUeNgcGyEYRGhGshIPllDfU+VPaGLtwtimHp1it2ITk6e +QNuozDJ0uW8NxuOzRAvZim+aKZuZGCg70eNAKJpaPNW15yAbi8qkq43pUdniTCxZ +qdq5snUb9kLy78fyGPmJvKP/iiMucEc= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDZzCCAk+gAwIBAgIQGx+ttiD5JNM2a/fH8YygWTANBgkqhkiG9w0BAQUFADBF +MQswCQYDVQQGEwJHQjEYMBYGA1UEChMPVHJ1c3RpcyBMaW1pdGVkMRwwGgYDVQQL +ExNUcnVzdGlzIEZQUyBSb290IENBMB4XDTAzMTIyMzEyMTQwNloXDTI0MDEyMTEx +MzY1NFowRTELMAkGA1UEBhMCR0IxGDAWBgNVBAoTD1RydXN0aXMgTGltaXRlZDEc +MBoGA1UECxMTVHJ1c3RpcyBGUFMgUm9vdCBDQTCCASIwDQYJKoZIhvcNAQEBBQAD +ggEPADCCAQoCggEBAMVQe547NdDfxIzNjpvto8A2mfRC6qc+gIMPpqdZh8mQRUN+ +AOqGeSoDvT03mYlmt+WKVoaTnGhLaASMk5MCPjDSNzoiYYkchU59j9WvezX2fihH +iTHcDnlkH5nSW7r+f2C/revnPDgpai/lkQtV/+xvWNUtyd5MZnGPDNcE2gfmHhjj +vSkCqPoc4Vu5g6hBSLwacY3nYuUtsuvffM/bq1rKMfFMIvMFE/eC+XN5DL7XSxzA +0RU8k0Fk0ea+IxciAIleH2ulrG6nS4zto3Lmr2NNL4XSFDWaLk6M6jKYKIahkQlB +OrTh4/L68MkKokHdqeMDx4gVOxzUGpTXn2RZEm0CAwEAAaNTMFEwDwYDVR0TAQH/ +BAUwAwEB/zAfBgNVHSMEGDAWgBS6+nEleYtXQSUhhgtx67JkDoshZzAdBgNVHQ4E +FgQUuvpxJXmLV0ElIYYLceuyZA6LIWcwDQYJKoZIhvcNAQEFBQADggEBAH5Y//01 +GX2cGE+esCu8jowU/yyg2kdbw++BLa8F6nRIW/M+TgfHbcWzk88iNVy2P3UnXwmW +zaD+vkAMXBJV+JOCyinpXj9WV4s4NvdFGkwozZ5BuO1WTISkQMi4sKUraXAEasP4 +1BIy+Q7DsdwyhEQsb8tGD+pmQQ9P8Vilpg0ND2HepZ5dfWWhPBfnqFVO76DH7cZE +f1T1o+CP8HxVIo8ptoGj4W1OLBuAZ+ytIJ8MYmHVl/9D7S3B2l0pKoU/rGXuhg8F +jZBf3+6f9L/uHfuY5H+QK4R4EA5sSVPvFVtlRkpdr7r7OnIdzfYliB6XzCGcKQEN +ZetX2fNXlrtIzYE= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFFzCCA/+gAwIBAgIBETANBgkqhkiG9w0BAQUFADCCASsxCzAJBgNVBAYTAlRS +MRgwFgYDVQQHDA9HZWJ6ZSAtIEtvY2FlbGkxRzBFBgNVBAoMPlTDvHJraXllIEJp +bGltc2VsIHZlIFRla25vbG9qaWsgQXJhxZ90xLFybWEgS3VydW11IC0gVMOcQsSw +VEFLMUgwRgYDVQQLDD9VbHVzYWwgRWxla3Ryb25payB2ZSBLcmlwdG9sb2ppIEFy +YcWfdMSxcm1hIEVuc3RpdMO8c8O8IC0gVUVLQUUxIzAhBgNVBAsMGkthbXUgU2Vy +dGlmaWthc3lvbiBNZXJrZXppMUowSAYDVQQDDEFUw5xCxLBUQUsgVUVLQUUgS8O2 +ayBTZXJ0aWZpa2EgSGl6bWV0IFNhxJ9sYXnEsWPEsXPEsSAtIFPDvHLDvG0gMzAe +Fw0wNzA4MjQxMTM3MDdaFw0xNzA4MjExMTM3MDdaMIIBKzELMAkGA1UEBhMCVFIx +GDAWBgNVBAcMD0dlYnplIC0gS29jYWVsaTFHMEUGA1UECgw+VMO8cmtpeWUgQmls +aW1zZWwgdmUgVGVrbm9sb2ppayBBcmHFn3TEsXJtYSBLdXJ1bXUgLSBUw5xCxLBU +QUsxSDBGBgNVBAsMP1VsdXNhbCBFbGVrdHJvbmlrIHZlIEtyaXB0b2xvamkgQXJh +xZ90xLFybWEgRW5zdGl0w7xzw7wgLSBVRUtBRTEjMCEGA1UECwwaS2FtdSBTZXJ0 +aWZpa2FzeW9uIE1lcmtlemkxSjBIBgNVBAMMQVTDnELEsFRBSyBVRUtBRSBLw7Zr +IFNlcnRpZmlrYSBIaXptZXQgU2HEn2xhecSxY8Sxc8SxIC0gU8O8csO8bSAzMIIB +IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAim1L/xCIOsP2fpTo6iBkcK4h +gb46ezzb8R1Sf1n68yJMlaCQvEhOEav7t7WNeoMojCZG2E6VQIdhn8WebYGHV2yK +O7Rm6sxA/OOqbLLLAdsyv9Lrhc+hDVXDWzhXcLh1xnnRFDDtG1hba+818qEhTsXO +fJlfbLm4IpNQp81McGq+agV/E5wrHur+R84EpW+sky58K5+eeROR6Oqeyjh1jmKw +lZMq5d/pXpduIF9fhHpEORlAHLpVK/swsoHvhOPc7Jg4OQOFCKlUAwUp8MmPi+oL +hmUZEdPpCSPeaJMDyTYcIW7OjGbxmTDY17PDHfiBLqi9ggtm/oLL4eAagsNAgQID +AQABo0IwQDAdBgNVHQ4EFgQUvYiHyY/2pAoLquvF/pEjnatKijIwDgYDVR0PAQH/ +BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEFBQADggEBAB18+kmP +NOm3JpIWmgV050vQbTlswyb2zrgxvMTfvCr4N5EY3ATIZJkrGG2AA1nJrvhY0D7t +wyOfaTyGOBye79oneNGEN3GKPEs5z35FBtYt2IpNeBLWrcLTy9LQQfMmNkqblWwM +7uXRQydmwYj3erMgbOqwaSvHIOgMA8RBBZniP+Rr+KCGgceExh/VS4ESshYhLBOh +gLJeDEoTniDYYkCrkOpkSi+sDQESeUWoL4cZaMjihccwsnX5OD+ywJO0a+IDRM5n +oN+J1q2MdqMTw5RhK2vZbMEHCiIHhWyFJEapvj+LeISCfiQMnf2BN+MlqO02TpUs +yZyQ2uypQjyttgI= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICjzCCAhWgAwIBAgIQXIuZxVqUxdJxVt7NiYDMJjAKBggqhkjOPQQDAzCBiDEL +MAkGA1UEBhMCVVMxEzARBgNVBAgTCk5ldyBKZXJzZXkxFDASBgNVBAcTC0plcnNl +eSBDaXR5MR4wHAYDVQQKExVUaGUgVVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNVBAMT +JVVTRVJUcnVzdCBFQ0MgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMTAwMjAx +MDAwMDAwWhcNMzgwMTE4MjM1OTU5WjCBiDELMAkGA1UEBhMCVVMxEzARBgNVBAgT +Ck5ldyBKZXJzZXkxFDASBgNVBAcTC0plcnNleSBDaXR5MR4wHAYDVQQKExVUaGUg +VVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNVBAMTJVVTRVJUcnVzdCBFQ0MgQ2VydGlm +aWNhdGlvbiBBdXRob3JpdHkwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQarFRaqflo +I+d61SRvU8Za2EurxtW20eZzca7dnNYMYf3boIkDuAUU7FfO7l0/4iGzzvfUinng +o4N+LZfQYcTxmdwlkWOrfzCjtHDix6EznPO/LlxTsV+zfTJ/ijTjeXmjQjBAMB0G +A1UdDgQWBBQ64QmG1M8ZwpZ2dEl23OA1xmNjmjAOBgNVHQ8BAf8EBAMCAQYwDwYD +VR0TAQH/BAUwAwEB/zAKBggqhkjOPQQDAwNoADBlAjA2Z6EWCNzklwBBHU6+4WMB +zzuqQhFkoJ2UOQIReVx7Hfpkue4WQrO/isIJxOzksU0CMQDpKmFHjFJKS04YcPbW +RNZu9YO6bVi9JNlWSOrvxKJGgYhqOkbRqZtNyWHa0V1Xahg= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIF3jCCA8agAwIBAgIQAf1tMPyjylGoG7xkDjUDLTANBgkqhkiG9w0BAQwFADCB +iDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCk5ldyBKZXJzZXkxFDASBgNVBAcTC0pl +cnNleSBDaXR5MR4wHAYDVQQKExVUaGUgVVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNV +BAMTJVVTRVJUcnVzdCBSU0EgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMTAw +MjAxMDAwMDAwWhcNMzgwMTE4MjM1OTU5WjCBiDELMAkGA1UEBhMCVVMxEzARBgNV +BAgTCk5ldyBKZXJzZXkxFDASBgNVBAcTC0plcnNleSBDaXR5MR4wHAYDVQQKExVU +aGUgVVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNVBAMTJVVTRVJUcnVzdCBSU0EgQ2Vy +dGlmaWNhdGlvbiBBdXRob3JpdHkwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIK +AoICAQCAEmUXNg7D2wiz0KxXDXbtzSfTTK1Qg2HiqiBNCS1kCdzOiZ/MPans9s/B +3PHTsdZ7NygRK0faOca8Ohm0X6a9fZ2jY0K2dvKpOyuR+OJv0OwWIJAJPuLodMkY +tJHUYmTbf6MG8YgYapAiPLz+E/CHFHv25B+O1ORRxhFnRghRy4YUVD+8M/5+bJz/ +Fp0YvVGONaanZshyZ9shZrHUm3gDwFA66Mzw3LyeTP6vBZY1H1dat//O+T23LLb2 +VN3I5xI6Ta5MirdcmrS3ID3KfyI0rn47aGYBROcBTkZTmzNg95S+UzeQc0PzMsNT +79uq/nROacdrjGCT3sTHDN/hMq7MkztReJVni+49Vv4M0GkPGw/zJSZrM233bkf6 +c0Plfg6lZrEpfDKEY1WJxA3Bk1QwGROs0303p+tdOmw1XNtB1xLaqUkL39iAigmT +Yo61Zs8liM2EuLE/pDkP2QKe6xJMlXzzawWpXhaDzLhn4ugTncxbgtNMs+1b/97l +c6wjOy0AvzVVdAlJ2ElYGn+SNuZRkg7zJn0cTRe8yexDJtC/QV9AqURE9JnnV4ee +UB9XVKg+/XRjL7FQZQnmWEIuQxpMtPAlR1n6BB6T1CZGSlCBst6+eLf8ZxXhyVeE +Hg9j1uliutZfVS7qXMYoCAQlObgOK6nyTJccBz8NUvXt7y+CDwIDAQABo0IwQDAd +BgNVHQ4EFgQUU3m/WqorSs9UgOHYm8Cd8rIDZsswDgYDVR0PAQH/BAQDAgEGMA8G +A1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEMBQADggIBAFzUfA3P9wF9QZllDHPF +Up/L+M+ZBn8b2kMVn54CVVeWFPFSPCeHlCjtHzoBN6J2/FNQwISbxmtOuowhT6KO +VWKR82kV2LyI48SqC/3vqOlLVSoGIG1VeCkZ7l8wXEskEVX/JJpuXior7gtNn3/3 +ATiUFJVDBwn7YKnuHKsSjKCaXqeYalltiz8I+8jRRa8YFWSQEg9zKC7F4iRO/Fjs +8PRF/iKz6y+O0tlFYQXBl2+odnKPi4w2r78NBc5xjeambx9spnFixdjQg3IM8WcR +iQycE0xyNN+81XHfqnHd4blsjDwSXWXavVcStkNr/+XeTWYRUc+ZruwXtuhxkYze +Sf7dNXGiFSeUHM9h4ya7b6NnJSFd5t0dCy5oGzuCr+yDZ4XUmFF0sbmZgIn/f3gZ +XHlKYC6SQK5MNyosycdiyA5d9zZbyuAlJQG03RoHnHcAP9Dc1ew91Pq7P8yF1m9/ +qS3fuQL39ZeatTXaw2ewh0qpKJ4jjv9cJ2vhsE/zB+4ALtRZh8tSQZXq9EfX7mRB +VXyNWQKV3WKdwrnuWih0hKWbt5DHDAff9Yk2dDLWKMGwsAvgnEzDHNb842m1R0aB +L6KCq9NjRHDEjf8tM7qtj3u1cIiuPhnPQCjY/MiQu12ZIvVS5ljFH4gxQ+6IHdfG +jjxDah2nGN59PRbxYvnKkKj9 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEXjCCA0agAwIBAgIQRL4Mi1AAIbQR0ypoBqmtaTANBgkqhkiG9w0BAQUFADCB +kzELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2Ug +Q2l0eTEeMBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExho +dHRwOi8vd3d3LnVzZXJ0cnVzdC5jb20xGzAZBgNVBAMTElVUTiAtIERBVEFDb3Jw +IFNHQzAeFw05OTA2MjQxODU3MjFaFw0xOTA2MjQxOTA2MzBaMIGTMQswCQYDVQQG +EwJVUzELMAkGA1UECBMCVVQxFzAVBgNVBAcTDlNhbHQgTGFrZSBDaXR5MR4wHAYD +VQQKExVUaGUgVVNFUlRSVVNUIE5ldHdvcmsxITAfBgNVBAsTGGh0dHA6Ly93d3cu +dXNlcnRydXN0LmNvbTEbMBkGA1UEAxMSVVROIC0gREFUQUNvcnAgU0dDMIIBIjAN +BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA3+5YEKIrblXEjr8uRgnn4AgPLit6 +E5Qbvfa2gI5lBZMAHryv4g+OGQ0SR+ysraP6LnD43m77VkIVni5c7yPeIbkFdicZ +D0/Ww5y0vpQZY/KmEQrrU0icvvIpOxboGqBMpsn0GFlowHDyUwDAXlCCpVZvNvlK +4ESGoE1O1kduSUrLZ9emxAW5jh70/P/N5zbgnAVssjMiFdC04MwXwLLA9P4yPykq +lXvY8qdOD1R8oQ2AswkDwf9c3V6aPryuvEeKaq5xyh+xKrhfQgUL7EYw0XILyulW +bfXv33i+Ybqypa4ETLyorGkVl73v67SMvzX41MPRKA5cOp9wGDMgd8SirwIDAQAB +o4GrMIGoMAsGA1UdDwQEAwIBxjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRT +MtGzz3/64PGgXYVOktKeRR20TzA9BgNVHR8ENjA0MDKgMKAuhixodHRwOi8vY3Js +LnVzZXJ0cnVzdC5jb20vVVROLURBVEFDb3JwU0dDLmNybDAqBgNVHSUEIzAhBggr +BgEFBQcDAQYKKwYBBAGCNwoDAwYJYIZIAYb4QgQBMA0GCSqGSIb3DQEBBQUAA4IB +AQAnNZcAiosovcYzMB4p/OL31ZjUQLtgyr+rFywJNn9Q+kHcrpY6CiM+iVnJowft +Gzet/Hy+UUla3joKVAgWRcKZsYfNjGjgaQPpxE6YsjuMFrMOoAyYUJuTqXAJyCyj +j98C5OBxOvG0I3KgqgHf35g+FFCgMSa9KOlaMCZ1+XtgHI3zzVAmbQQnmt/VDUVH +KWss5nbZqSl9Mt3JNjy9rjXxEZ4du5A/EkdOjtd+D2JzHVImOBwYSf0wdJrE5SIv +2MCN7ZF6TACPcn9d2t0bi0Vr591pl6jFVkwPDPafepE39peC4N1xaf92P2BNPM/3 +mfnGV/TJVTl4uix5yaaIK/QI +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEdDCCA1ygAwIBAgIQRL4Mi1AAJLQR0zYq/mUK/TANBgkqhkiG9w0BAQUFADCB +lzELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2Ug +Q2l0eTEeMBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExho +dHRwOi8vd3d3LnVzZXJ0cnVzdC5jb20xHzAdBgNVBAMTFlVUTi1VU0VSRmlyc3Qt +SGFyZHdhcmUwHhcNOTkwNzA5MTgxMDQyWhcNMTkwNzA5MTgxOTIyWjCBlzELMAkG +A1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2UgQ2l0eTEe +MBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExhodHRwOi8v +d3d3LnVzZXJ0cnVzdC5jb20xHzAdBgNVBAMTFlVUTi1VU0VSRmlyc3QtSGFyZHdh +cmUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCx98M4P7Sof885glFn +0G2f0v9Y8+efK+wNiVSZuTiZFvfgIXlIwrthdBKWHTxqctU8EGc6Oe0rE81m65UJ +M6Rsl7HoxuzBdXmcRl6Nq9Bq/bkqVRcQVLMZ8Jr28bFdtqdt++BxF2uiiPsA3/4a +MXcMmgF6sTLjKwEHOG7DpV4jvEWbe1DByTCP2+UretNb+zNAHqDVmBe8i4fDidNd +oI6yqqr2jmmIBsX6iSHzCJ1pLgkzmykNRg+MzEk0sGlRvfkGzWitZky8PqxhvQqI +DsjfPe58BEydCl5rkdbux+0ojatNh4lz0G6k0B4WixThdkQDf2Os5M1JnMWS9Ksy +oUhbAgMBAAGjgbkwgbYwCwYDVR0PBAQDAgHGMA8GA1UdEwEB/wQFMAMBAf8wHQYD +VR0OBBYEFKFyXyYbKJhDlV0HN9WFlp1L0sNFMEQGA1UdHwQ9MDswOaA3oDWGM2h0 +dHA6Ly9jcmwudXNlcnRydXN0LmNvbS9VVE4tVVNFUkZpcnN0LUhhcmR3YXJlLmNy +bDAxBgNVHSUEKjAoBggrBgEFBQcDAQYIKwYBBQUHAwUGCCsGAQUFBwMGBggrBgEF +BQcDBzANBgkqhkiG9w0BAQUFAAOCAQEARxkP3nTGmZev/K0oXnWO6y1n7k57K9cM +//bey1WiCuFMVGWTYGufEpytXoMs61quwOQt9ABjHbjAbPLPSbtNk28Gpgoiskli +CE7/yMgUsogWXecB5BKV5UU0s4tpvc+0hY91UZ59Ojg6FEgSxvunOxqNDYJAB+gE +CJChicsZUN/KHAG8HQQZexB2lzvukJDKxA4fFm517zP4029bHpbj4HR3dHuKom4t +3XbWOTCC8KucUvIqx69JXn7HaOWCgchqJ/kniCrVWFCVH/A7HFe7fRQ5YiuayZSS +KqMiDP+JJn1fIytH1xUdqWqeUQ0qUZ6B+dQ7XnASfxAynB67nfhmqA== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIC5zCCAlACAQEwDQYJKoZIhvcNAQEFBQAwgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0 +IFZhbGlkYXRpb24gTmV0d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAz +BgNVBAsTLFZhbGlDZXJ0IENsYXNzIDEgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9y +aXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG +9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMB4XDTk5MDYyNTIyMjM0OFoXDTE5MDYy +NTIyMjM0OFowgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0IFZhbGlkYXRpb24gTmV0d29y +azEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENs +YXNzIDEgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9yaXR5MSEwHwYDVQQDExhodHRw +Oi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG9w0BCQEWEWluZm9AdmFsaWNl +cnQuY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDYWYJ6ibiWuqYvaG9Y +LqdUHAZu9OqNSLwxlBfw8068srg1knaw0KWlAdcAAxIiGQj4/xEjm84H9b9pGib+ +TunRf50sQB1ZaG6m+FiwnRqP0z/x3BkGgagO4DrdyFNFCQbmD3DD+kCmDuJWBQ8Y +TfwggtFzVXSNdnKgHZ0dwN0/cQIDAQABMA0GCSqGSIb3DQEBBQUAA4GBAFBoPUn0 +LBwGlN+VYH+Wexf+T3GtZMjdd9LvWVXoP+iOBSoh8gfStadS/pyxtuJbdxdA6nLW +I8sogTLDAHkY7FkXicnGah5xyf23dKUlRWnFSKsZ4UWKJWsZ7uW7EvV/96aNUcPw +nXS3qT6gpf+2SQMT2iLM7XGCK5nPOrf1LXLI +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIC5zCCAlACAQEwDQYJKoZIhvcNAQEFBQAwgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0 +IFZhbGlkYXRpb24gTmV0d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAz +BgNVBAsTLFZhbGlDZXJ0IENsYXNzIDIgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9y +aXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG +9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMB4XDTk5MDYyNjAwMTk1NFoXDTE5MDYy +NjAwMTk1NFowgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0IFZhbGlkYXRpb24gTmV0d29y +azEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENs +YXNzIDIgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9yaXR5MSEwHwYDVQQDExhodHRw +Oi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG9w0BCQEWEWluZm9AdmFsaWNl +cnQuY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDOOnHK5avIWZJV16vY +dA757tn2VUdZZUcOBVXc65g2PFxTXdMwzzjsvUGJ7SVCCSRrCl6zfN1SLUzm1NZ9 +WlmpZdRJEy0kTRxQb7XBhVQ7/nHk01xC+YDgkRoKWzk2Z/M/VXwbP7RfZHM047QS +v4dk+NoS/zcnwbNDu+97bi5p9wIDAQABMA0GCSqGSIb3DQEBBQUAA4GBADt/UG9v +UJSZSWI4OB9L+KXIPqeCgfYrx+jFzug6EILLGACOTb2oWH+heQC1u+mNr0HZDzTu +IYEZoDJJKPTEjlbVUjP9UNV+mWwD5MlM/Mtsq2azSiGM5bUMMj4QssxsodyamEwC +W/POuZ6lcg5Ktz885hZo+L7tdEy8W9ViH0Pd +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDhDCCAwqgAwIBAgIQL4D+I4wOIg9IZxIokYesszAKBggqhkjOPQQDAzCByjEL +MAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZW +ZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNyBWZXJpU2ln +biwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxWZXJp +U2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9y +aXR5IC0gRzQwHhcNMDcxMTA1MDAwMDAwWhcNMzgwMTE4MjM1OTU5WjCByjELMAkG +A1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZWZXJp +U2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNyBWZXJpU2lnbiwg +SW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxWZXJpU2ln +biBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5 +IC0gRzQwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAASnVnp8Utpkmw4tXNherJI9/gHm +GUo9FANL+mAnINmDiWn6VMaaGF5VKmTeBvaNSjutEDxlPZCIBIngMGGzrl0Bp3ve +fLK+ymVhAIau2o970ImtTR1ZmkGxvEeA3J5iw/mjgbIwga8wDwYDVR0TAQH/BAUw +AwEB/zAOBgNVHQ8BAf8EBAMCAQYwbQYIKwYBBQUHAQwEYTBfoV2gWzBZMFcwVRYJ +aW1hZ2UvZ2lmMCEwHzAHBgUrDgMCGgQUj+XTGoasjY5rw8+AatRIGCx7GS4wJRYj +aHR0cDovL2xvZ28udmVyaXNpZ24uY29tL3ZzbG9nby5naWYwHQYDVR0OBBYEFLMW +kf3upm7ktS5Jj4d4gYDs5bG1MAoGCCqGSM49BAMDA2gAMGUCMGYhDBgmYFo4e1ZC +4Kf8NoRRkSAsdk1DPcQdhCPQrNZ8NQbOzWm9kA3bbEhCHQ6qQgIxAJw9SDkjOVga +FRJZap7v1VmyHVIsmXHNxynfGyphe3HR3vPA5Q06Sqotp9iGKt0uEA== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIE0zCCA7ugAwIBAgIQGNrRniZ96LtKIVjNzGs7SjANBgkqhkiG9w0BAQUFADCB +yjELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL +ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNiBWZXJp +U2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxW +ZXJpU2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0 +aG9yaXR5IC0gRzUwHhcNMDYxMTA4MDAwMDAwWhcNMzYwNzE2MjM1OTU5WjCByjEL +MAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZW +ZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNiBWZXJpU2ln +biwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxWZXJp +U2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9y +aXR5IC0gRzUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvJAgIKXo1 +nmAMqudLO07cfLw8RRy7K+D+KQL5VwijZIUVJ/XxrcgxiV0i6CqqpkKzj/i5Vbex +t0uz/o9+B1fs70PbZmIVYc9gDaTY3vjgw2IIPVQT60nKWVSFJuUrjxuf6/WhkcIz +SdhDY2pSS9KP6HBRTdGJaXvHcPaz3BJ023tdS1bTlr8Vd6Gw9KIl8q8ckmcY5fQG +BO+QueQA5N06tRn/Arr0PO7gi+s3i+z016zy9vA9r911kTMZHRxAy3QkGSGT2RT+ +rCpSx4/VBEnkjWNHiDxpg8v+R70rfk/Fla4OndTRQ8Bnc+MUCH7lP59zuDMKz10/ +NIeWiu5T6CUVAgMBAAGjgbIwga8wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8E +BAMCAQYwbQYIKwYBBQUHAQwEYTBfoV2gWzBZMFcwVRYJaW1hZ2UvZ2lmMCEwHzAH +BgUrDgMCGgQUj+XTGoasjY5rw8+AatRIGCx7GS4wJRYjaHR0cDovL2xvZ28udmVy +aXNpZ24uY29tL3ZzbG9nby5naWYwHQYDVR0OBBYEFH/TZafC3ey78DAJ80M5+gKv +MzEzMA0GCSqGSIb3DQEBBQUAA4IBAQCTJEowX2LP2BqYLz3q3JktvXf2pXkiOOzE +p6B4Eq1iDkVwZMXnl2YtmAl+X6/WzChl8gGqCBpH3vn5fJJaCGkgDdk+bW48DW7Y +5gaRQBi5+MHt39tBquCWIMnNZBU4gcmU7qKEKQsTb47bDN0lAtukixlE0kF6BWlK +WE9gyn6CagsCqiUXObXbf+eEZSqVir2G3l6BFoMtEMze/aiCKm0oHw0LxOXnGiYZ +4fQRbxC1lfznQgUy286dUV4otp6F01vvpX1FQHKOtw5rDgb7MzVIcbidJ4vEZV8N +hnacRHr2lVz2XTIIM6RUthg/aFzyQkqFOFSDX9HoLPKsEdao7WNq +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEuTCCA6GgAwIBAgIQQBrEZCGzEyEDDrvkEhrFHTANBgkqhkiG9w0BAQsFADCB +vTELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL +ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwOCBWZXJp +U2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MTgwNgYDVQQDEy9W +ZXJpU2lnbiBVbml2ZXJzYWwgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAe +Fw0wODA0MDIwMDAwMDBaFw0zNzEyMDEyMzU5NTlaMIG9MQswCQYDVQQGEwJVUzEX +MBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZlcmlTaWduIFRydXN0 +IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAyMDA4IFZlcmlTaWduLCBJbmMuIC0gRm9y +IGF1dGhvcml6ZWQgdXNlIG9ubHkxODA2BgNVBAMTL1ZlcmlTaWduIFVuaXZlcnNh +bCBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEF +AAOCAQ8AMIIBCgKCAQEAx2E3XrEBNNti1xWb/1hajCMj1mCOkdeQmIN65lgZOIzF +9uVkhbSicfvtvbnazU0AtMgtc6XHaXGVHzk8skQHnOgO+k1KxCHfKWGPMiJhgsWH +H26MfF8WIFFE0XBPV+rjHOPMee5Y2A7Cs0WTwCznmhcrewA3ekEzeOEz4vMQGn+H +LL729fdC4uW/h2KJXwBL38Xd5HVEMkE6HnFuacsLdUYI0crSK5XQz/u5QGtkjFdN +/BMReYTtXlT2NJ8IAfMQJQYXStrxHXpma5hgZqTZ79IugvHw7wnqRMkVauIDbjPT +rJ9VAMf2CGqUuV/c4DPxhGD5WycRtPwW8rtWaoAljQIDAQABo4GyMIGvMA8GA1Ud +EwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMG0GCCsGAQUFBwEMBGEwX6FdoFsw +WTBXMFUWCWltYWdlL2dpZjAhMB8wBwYFKw4DAhoEFI/l0xqGrI2Oa8PPgGrUSBgs +exkuMCUWI2h0dHA6Ly9sb2dvLnZlcmlzaWduLmNvbS92c2xvZ28uZ2lmMB0GA1Ud +DgQWBBS2d/ppSEefUxLVwuoHMnYH0ZcHGTANBgkqhkiG9w0BAQsFAAOCAQEASvj4 +sAPmLGd75JR3Y8xuTPl9Dg3cyLk1uXBPY/ok+myDjEedO2Pzmvl2MpWRsXe8rJq+ +seQxIcaBlVZaDrHC1LGmWazxY8u4TB1ZkErvkBYoH1quEPuBUDgMbMzxPcP1Y+Oz +4yHJJDnp/RVmRvQbEdBNc6N9Rvk97ahfYtTxP/jgdFcrGJ2BtMQo2pSXpXDrrB2+ +BxHw1dvd5Yzw1TKwg+ZX4o+/vqGqvz0dtdQ46tewXDpPaj+PwGZsY6rp2aQW9IHR +lRQOfc2VNNnSj3BzgXucfr2YYdhFh5iQxeuGMMY1v/D/w1WIg0vvBZIGcfK4mJO3 +7M2CYfE45k+XmCpajQ== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICPDCCAaUCEHC65B0Q2Sk0tjjKewPMur8wDQYJKoZIhvcNAQECBQAwXzELMAkG +A1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFz +cyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTk2 +MDEyOTAwMDAwMFoXDTI4MDgwMTIzNTk1OVowXzELMAkGA1UEBhMCVVMxFzAVBgNV +BAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFzcyAzIFB1YmxpYyBQcmlt +YXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIGfMA0GCSqGSIb3DQEBAQUAA4GN +ADCBiQKBgQDJXFme8huKARS0EN8EQNvjV69qRUCPhAwL0TPZ2RHP7gJYHyX3KqhE +BarsAx94f56TuZoAqiN91qyFomNFx3InzPRMxnVx0jnvT0Lwdd8KkMaOIG+YD/is +I19wKTakyYbnsZogy1Olhec9vn2a/iRFM9x2Fe0PonFkTGUugWhFpwIDAQABMA0G +CSqGSIb3DQEBAgUAA4GBALtMEivPLCYATxQT3ab7/AoRhIzzKBxnki98tsX63/Do +lbwdj2wsqFHMc9ikwFPwTtYmwHYBV4GSXiHx0bH/59AhWM1pF+NEHJwZRDmJXNyc +AA9WjQKZ7aKQRUzkuxCkPfAyAw7xzvjoyVGM5mKf5p/AfbdynMk2OmufTqj/ZA1k +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICPDCCAaUCEDyRMcsf9tAbDpq40ES/Er4wDQYJKoZIhvcNAQEFBQAwXzELMAkG +A1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFz +cyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTk2 +MDEyOTAwMDAwMFoXDTI4MDgwMjIzNTk1OVowXzELMAkGA1UEBhMCVVMxFzAVBgNV +BAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFzcyAzIFB1YmxpYyBQcmlt +YXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIGfMA0GCSqGSIb3DQEBAQUAA4GN +ADCBiQKBgQDJXFme8huKARS0EN8EQNvjV69qRUCPhAwL0TPZ2RHP7gJYHyX3KqhE +BarsAx94f56TuZoAqiN91qyFomNFx3InzPRMxnVx0jnvT0Lwdd8KkMaOIG+YD/is +I19wKTakyYbnsZogy1Olhec9vn2a/iRFM9x2Fe0PonFkTGUugWhFpwIDAQABMA0G +CSqGSIb3DQEBBQUAA4GBABByUqkFFBkyCEHwxWsKzH4PIRnN5GfcX6kb5sroc50i +2JhucwNhkcV8sEVAbkSdjbCxlnRhLQ2pRdKkkirWmnWXbj9T/UWZYB2oK0z5XqcJ +2HUw19JlYD1n1khVdWk/kfVIC0dpImmClr7JyDiGSnoscxlIaU5rfGW/D/xwzoiQ +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDAjCCAmsCEH3Z/gfPqB63EHln+6eJNMYwDQYJKoZIhvcNAQEFBQAwgcExCzAJ +BgNVBAYTAlVTMRcwFQYDVQQKEw5WZXJpU2lnbiwgSW5jLjE8MDoGA1UECxMzQ2xh +c3MgMyBQdWJsaWMgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEcy +MTowOAYDVQQLEzEoYykgMTk5OCBWZXJpU2lnbiwgSW5jLiAtIEZvciBhdXRob3Jp +emVkIHVzZSBvbmx5MR8wHQYDVQQLExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMB4X +DTk4MDUxODAwMDAwMFoXDTI4MDgwMTIzNTk1OVowgcExCzAJBgNVBAYTAlVTMRcw +FQYDVQQKEw5WZXJpU2lnbiwgSW5jLjE8MDoGA1UECxMzQ2xhc3MgMyBQdWJsaWMg +UHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEcyMTowOAYDVQQLEzEo +YykgMTk5OCBWZXJpU2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5 +MR8wHQYDVQQLExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMIGfMA0GCSqGSIb3DQEB +AQUAA4GNADCBiQKBgQDMXtERXVxp0KvTuWpMmR9ZmDCOFoUgRm1HP9SFIIThbbP4 +pO0M8RcPO/mn+SXXwc+EY/J8Y8+iR/LGWzOOZEAEaMGAuWQcRXfH2G71lSk8UOg0 +13gfqLptQ5GVj0VXXn7F+8qkBOvqlzdUMG+7AUcyM83cV5tkaWH4mx0ciU9cZwID +AQABMA0GCSqGSIb3DQEBBQUAA4GBAFFNzb5cy5gZnBWyATl4Lk0PZ3BwmcYQWpSk +U01UbSuvDV1Ai2TT1+7eVmGSX6bEHRBhNtMsJzzoKQm5EWR0zLVznxxIqbxhAe7i +F6YM40AIOw7n60RzKprxaZLvcRTDOaxxp5EJb+RxBrO6WVcmeQD2+A2iMzAo1KpY +oJ2daZH9 +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEGjCCAwICEQCbfgZJoz5iudXukEhxKe9XMA0GCSqGSIb3DQEBBQUAMIHKMQsw +CQYDVQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZl +cmlTaWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWdu +LCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlT +aWduIENsYXNzIDMgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3Jp +dHkgLSBHMzAeFw05OTEwMDEwMDAwMDBaFw0zNjA3MTYyMzU5NTlaMIHKMQswCQYD +VQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZlcmlT +aWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWduLCBJ +bmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlTaWdu +IENsYXNzIDMgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkg +LSBHMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMu6nFL8eB8aHm8b +N3O9+MlrlBIwT/A2R/XQkQr1F8ilYcEWQE37imGQ5XYgwREGfassbqb1EUGO+i2t +KmFZpGcmTNDovFJbcCAEWNF6yaRpvIMXZK0Fi7zQWM6NjPXr8EJJC52XJ2cybuGu +kxUccLwgTS8Y3pKI6GyFVxEa6X7jJhFUokWWVYPKMIno3Nij7SqAP395ZVc+FSBm +CC+Vk7+qRy+oRpfwEuL+wgorUeZ25rdGt+INpsyow0xZVYnm6FNcHOqd8GIWC6fJ +Xwzw3sJ2zq/3avL6QaaiMxTJ5Xpj055iN9WFZZ4O5lMkdBteHRJTW8cs54NJOxWu +imi5V5cCAwEAATANBgkqhkiG9w0BAQUFAAOCAQEAERSWwauSCPc/L8my/uRan2Te +2yFPhpk0djZX3dAVL8WtfxUfN2JzPtTnX84XA9s1+ivbrmAJXx5fj267Cz3qWhMe +DGBvtcC1IyIuBwvLqXTLR7sdwdela8wv0kL9Sd2nic9TutoAWii/gt/4uhMdUIaC +/Y4wjylGsB49Ndo4YhYYSq3mtlFs3q9i6wHQHiT+eo8SGhJouPtmmRQURVyu565p +F4ErWjfJXir0xuKhXFSbplQAz/DxwceYMBo7Nhbbo27q/a2ywtrvAkcTisDxszGt +TxzhT5yvDwyd93gN2PQ1VoDat20Xj50egWTh/sVFuq1ruQp6Tk9LhO5L8X3dEQ== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEGjCCAwICEQDsoKeLbnVqAc/EfMwvlF7XMA0GCSqGSIb3DQEBBQUAMIHKMQsw +CQYDVQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZl +cmlTaWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWdu +LCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlT +aWduIENsYXNzIDQgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3Jp +dHkgLSBHMzAeFw05OTEwMDEwMDAwMDBaFw0zNjA3MTYyMzU5NTlaMIHKMQswCQYD +VQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZlcmlT +aWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWduLCBJ +bmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlTaWdu +IENsYXNzIDQgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkg +LSBHMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAK3LpRFpxlmr8Y+1 +GQ9Wzsy1HyDkniYlS+BzZYlZ3tCD5PUPtbut8XzoIfzk6AzufEUiGXaStBO3IFsJ ++mGuqPKljYXCKtbeZjbSmwL0qJJgfJxptI8kHtCGUvYynEFYHiK9zUVilQhu0Gbd +U6LM8BDcVHOLBKFGMzNcF0C5nk3T875Vg+ixiY5afJqWIpA7iCXy0lOIAgwLePLm +NxdLMEYH5IBtptiWLugs+BGzOA1mppvqySNb247i8xOOGlktqgLw7KSHZtzBP/XY +ufTsgsbSPZUd5cBPhMnZo0QoBmrXRazwa2rvTl/4EYIeOGM0ZlDUPpNz+jDDZq3/ +ky2X7wMCAwEAATANBgkqhkiG9w0BAQUFAAOCAQEAj/ola09b5KROJ1WrIhVZPMq1 +CtRK26vdoV9TxaBXOcLORyu+OshWv8LZJxA6sQU8wHcxuzrTBXttmhwwjIDLk5Mq +g6sFUYICABFna/OIYUdfA5PVWw3g8dShMjWFsjrbsIKr0csKvE+MW8VLADsfKoKm +fjaF3H48ZwC15DtS4KjrXRX5xm3wrR0OhbepmnMUWluPQSjA1egtTaRezarZ7c7c +2NU8Qh0XwRJdRTjDOPP8hS6DRkiy1yBfkjaP53kPmF6Z6PDQpLv1U70qzlmwr25/ +bLvSHgCwIe34QWKCudiyxLtGUPMxxY8BqHTr9Xgn2uf3ZkPznoM+IKrDNWCRzg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDojCCAoqgAwIBAgIQE4Y1TR0/BvLB+WUF1ZAcYjANBgkqhkiG9w0BAQUFADBr +MQswCQYDVQQGEwJVUzENMAsGA1UEChMEVklTQTEvMC0GA1UECxMmVmlzYSBJbnRl +cm5hdGlvbmFsIFNlcnZpY2UgQXNzb2NpYXRpb24xHDAaBgNVBAMTE1Zpc2EgZUNv +bW1lcmNlIFJvb3QwHhcNMDIwNjI2MDIxODM2WhcNMjIwNjI0MDAxNjEyWjBrMQsw +CQYDVQQGEwJVUzENMAsGA1UEChMEVklTQTEvMC0GA1UECxMmVmlzYSBJbnRlcm5h +dGlvbmFsIFNlcnZpY2UgQXNzb2NpYXRpb24xHDAaBgNVBAMTE1Zpc2EgZUNvbW1l +cmNlIFJvb3QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvV95WHm6h +2mCxlCfLF9sHP4CFT8icttD0b0/Pmdjh28JIXDqsOTPHH2qLJj0rNfVIsZHBAk4E +lpF7sDPwsRROEW+1QK8bRaVK7362rPKgH1g/EkZgPI2h4H3PVz4zHvtH8aoVlwdV +ZqW1LS7YgFmypw23RuwhY/81q6UCzyr0TP579ZRdhE2o8mCP2w4lPJ9zcc+U30rq +299yOIzzlr3xF7zSujtFWsan9sYXiwGd/BmoKoMWuDpI/k4+oKsGGelT84ATB+0t +vz8KPFUgOSwsAGl0lUq8ILKpeeUYiZGo3BxN77t+Nwtd/jmliFKMAGzsGHxBvfaL +dXe6YJ2E5/4tAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQD +AgEGMB0GA1UdDgQWBBQVOIMPPyw/cDMezUb+B4wg4NfDtzANBgkqhkiG9w0BAQUF +AAOCAQEAX/FBfXxcCLkr4NWSR/pnXKUTwwMhmytMiUbPWU3J/qVAtmPN3XEolWcR +zCSs00Rsca4BIGsDoo8Ytyk6feUWYFN4PMCvFYP3j1IzJL1kk5fui/fbGKhtcbP3 +LBfQdCVp9/5rPJS+TUtBjE7ic9DjkCJzQ83z7+pzzkWKsKZJ/0x9nXGIxHYdkFsd +7v3M9+79YKWxehZx0RbQfBI8bGmX265fOZpwLwU8GUYEmSA20GBuYQa7FkKMcPcw +++DbZqMAAb3mLNqRX6BGi01qnD093QVG/na/oAo85ADmJ7f/hC3euiInlhBx6yLt +398znM/jra6O1I7mT1GvFpLgXPYHDw== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEvTCCA6WgAwIBAgIBATANBgkqhkiG9w0BAQUFADCBhTELMAkGA1UEBhMCVVMx +IDAeBgNVBAoMF1dlbGxzIEZhcmdvIFdlbGxzU2VjdXJlMRwwGgYDVQQLDBNXZWxs +cyBGYXJnbyBCYW5rIE5BMTYwNAYDVQQDDC1XZWxsc1NlY3VyZSBQdWJsaWMgUm9v +dCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkwHhcNMDcxMjEzMTcwNzU0WhcNMjIxMjE0 +MDAwNzU0WjCBhTELMAkGA1UEBhMCVVMxIDAeBgNVBAoMF1dlbGxzIEZhcmdvIFdl +bGxzU2VjdXJlMRwwGgYDVQQLDBNXZWxscyBGYXJnbyBCYW5rIE5BMTYwNAYDVQQD +DC1XZWxsc1NlY3VyZSBQdWJsaWMgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkw +ggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDub7S9eeKPCCGeOARBJe+r +WxxTkqxtnt3CxC5FlAM1iGd0V+PfjLindo8796jE2yljDpFoNoqXjopxaAkH5OjU +Dk/41itMpBb570OYj7OeUt9tkTmPOL13i0Nj67eT/DBMHAGTthP796EfvyXhdDcs +HqRePGj4S78NuR4uNuip5Kf4D8uCdXw1LSLWwr8L87T8bJVhHlfXBIEyg1J55oNj +z7fLY4sR4r1e6/aN7ZVyKLSsEmLpSjPmgzKuBXWVvYSV2ypcm44uDLiBK0HmOFaf +SZtsdvqKXfcBeYF8wYNABf5x/Qw/zE5gCQ5lRxAvAcAFP4/4s0HvWkJ+We/Slwxl +AgMBAAGjggE0MIIBMDAPBgNVHRMBAf8EBTADAQH/MDkGA1UdHwQyMDAwLqAsoCqG +KGh0dHA6Ly9jcmwucGtpLndlbGxzZmFyZ28uY29tL3dzcHJjYS5jcmwwDgYDVR0P +AQH/BAQDAgHGMB0GA1UdDgQWBBQmlRkQ2eihl5H/3BnZtQQ+0nMKajCBsgYDVR0j +BIGqMIGngBQmlRkQ2eihl5H/3BnZtQQ+0nMKaqGBi6SBiDCBhTELMAkGA1UEBhMC +VVMxIDAeBgNVBAoMF1dlbGxzIEZhcmdvIFdlbGxzU2VjdXJlMRwwGgYDVQQLDBNX +ZWxscyBGYXJnbyBCYW5rIE5BMTYwNAYDVQQDDC1XZWxsc1NlY3VyZSBQdWJsaWMg +Um9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHmCAQEwDQYJKoZIhvcNAQEFBQADggEB +ALkVsUSRzCPIK0134/iaeycNzXK7mQDKfGYZUMbVmO2rvwNa5U3lHshPcZeG1eMd +/ZDJPHV3V3p9+N701NX3leZ0bh08rnyd2wIDBSxxSyU+B+NemvVmFymIGjifz6pB +A4SXa5M4esowRBskRDPQ5NHcKDj0E0M1NSljqHyita04pO2t/caaH/+Xc/77szWn +k4bGdpEA5qxRFsQnMlzbc9qlk1eOPm01JghZ1edE13YgY+esE2fDbbFwRnzVlhE9 +iW9dqKHrjQrawx0zbKPqZxmamX9LPYNRKh3KL4YMon4QLSvUFpULB6ouFJJJtylv +2G0xffX8oRAHh84vWdw+WNs= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFdjCCA16gAwIBAgIQXmjWEXGUY1BWAGjzPsnFkTANBgkqhkiG9w0BAQUFADBV +MQswCQYDVQQGEwJDTjEaMBgGA1UEChMRV29TaWduIENBIExpbWl0ZWQxKjAoBgNV +BAMTIUNlcnRpZmljYXRpb24gQXV0aG9yaXR5IG9mIFdvU2lnbjAeFw0wOTA4MDgw +MTAwMDFaFw0zOTA4MDgwMTAwMDFaMFUxCzAJBgNVBAYTAkNOMRowGAYDVQQKExFX +b1NpZ24gQ0EgTGltaXRlZDEqMCgGA1UEAxMhQ2VydGlmaWNhdGlvbiBBdXRob3Jp +dHkgb2YgV29TaWduMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAvcqN +rLiRFVaXe2tcesLea9mhsMMQI/qnobLMMfo+2aYpbxY94Gv4uEBf2zmoAHqLoE1U +fcIiePyOCbiohdfMlZdLdNiefvAA5A6JrkkoRBoQmTIPJYhTpA2zDxIIFgsDcScc +f+Hb0v1naMQFXQoOXXDX2JegvFNBmpGN9J42Znp+VsGQX+axaCA2pIwkLCxHC1l2 +ZjC1vt7tj/id07sBMOby8w7gLJKA84X5KIq0VC6a7fd2/BVoFutKbOsuEo/Uz/4M +x1wdC34FMr5esAkqQtXJTpCzWQ27en7N1QhatH/YHGkR+ScPewavVIMYe+HdVHpR +aG53/Ma/UkpmRqGyZxq7o093oL5d//xWC0Nyd5DKnvnyOfUNqfTq1+ezEC8wQjch +zDBwyYaYD8xYTYO7feUapTeNtqwylwA6Y3EkHp43xP901DfA4v6IRmAR3Qg/UDar +uHqklWJqbrDKaiFaafPz+x1wOZXzp26mgYmhiMU7ccqjUu6Du/2gd/Tkb+dC221K +mYo0SLwX3OSACCK28jHAPwQ+658geda4BmRkAjHXqc1S+4RFaQkAKtxVi8QGRkvA +Sh0JWzko/amrzgD5LkhLJuYwTKVYyrREgk/nkR4zw7CT/xH8gdLKH3Ep3XZPkiWv +HYG3Dy+MwwbMLyejSuQOmbp8HkUff6oZRZb9/D0CAwEAAaNCMEAwDgYDVR0PAQH/ +BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFOFmzw7R8bNLtwYgFP6H +EtX2/vs+MA0GCSqGSIb3DQEBBQUAA4ICAQCoy3JAsnbBfnv8rWTjMnvMPLZdRtP1 +LOJwXcgu2AZ9mNELIaCJWSQBnfmvCX0KI4I01fx8cpm5o9dU9OpScA7F9dY74ToJ +MuYhOZO9sxXqT2r09Ys/L3yNWC7F4TmgPsc9SnOeQHrAK2GpZ8nzJLmzbVUsWh2e +JXLOC62qx1ViC777Y7NhRCOjy+EaDveaBk3e1CNOIZZbOVtXHS9dCF4Jef98l7VN +g64N1uajeeAz0JmWAjCnPv/So0M/BVoG6kQC2nz4SNAzqfkHx5Xh9T71XXG68pWp +dIhhWeO/yloTunK0jF02h+mmxTwTv97QRCbut+wucPrXnbes5cVAWubXbHssw1ab +R80LzvobtCHXt2a49CUwi1wNuepnsvRtrtWhnk/Yn+knArAdBtaP4/tIEp9/EaEQ +PkxROpaw0RPxx9gmrjrKkcRpnd8BKWRRb2jaFOwIQZeQjdCygPLPwj2/kWjFgGce +xGATVdVhmVd8upUPYUk6ynW8yQqTP2cOEvIo4jEbwFcW3wh8GcF+Dx+FHgo2fFt+ +J7x6v+Db9NpSvd4MVHAxkUOVyLzwPt0JfjBkUO1/AaQzZ01oT74V77D2AhGiGxMl +OtzCWfHjXEa7ZywCRuoeSKbmW9m1vFGikpbbqsY3Iqb+zCB0oy2pLmvLwIIRIbWT +ee5Ehr7XHuQe+w== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFWDCCA0CgAwIBAgIQUHBrzdgT/BtOOzNy0hFIjTANBgkqhkiG9w0BAQsFADBG +MQswCQYDVQQGEwJDTjEaMBgGA1UEChMRV29TaWduIENBIExpbWl0ZWQxGzAZBgNV +BAMMEkNBIOayg+mAmuagueivgeS5pjAeFw0wOTA4MDgwMTAwMDFaFw0zOTA4MDgw +MTAwMDFaMEYxCzAJBgNVBAYTAkNOMRowGAYDVQQKExFXb1NpZ24gQ0EgTGltaXRl +ZDEbMBkGA1UEAwwSQ0Eg5rKD6YCa5qC56K+B5LmmMIICIjANBgkqhkiG9w0BAQEF +AAOCAg8AMIICCgKCAgEA0EkhHiX8h8EqwqzbdoYGTufQdDTc7WU1/FDWiD+k8H/r +D195L4mx/bxjWDeTmzj4t1up+thxx7S8gJeNbEvxUNUqKaqoGXqW5pWOdO2XCld1 +9AXbbQs5uQF/qvbW2mzmBeCkTVL829B0txGMe41P/4eDrv8FAxNXUDf+jJZSEExf +v5RxadmWPgxDT74wwJ85dE8GRV2j1lY5aAfMh09Qd5Nx2UQIsYo06Yms25tO4dnk +UkWMLhQfkWsZHWgpLFbE4h4TV2TwYeO5Ed+w4VegG63XX9Gv2ystP9Bojg/qnw+L +NVgbExz03jWhCl3W6t8Sb8D7aQdGctyB9gQjF+BNdeFyb7Ao65vh4YOhn0pdr8yb ++gIgthhid5E7o9Vlrdx8kHccREGkSovrlXLp9glk3Kgtn3R46MGiCWOc76DbT52V +qyBPt7D3h1ymoOQ3OMdc4zUPLK2jgKLsLl3Az+2LBcLmc272idX10kaO6m1jGx6K +yX2m+Jzr5dVjhU1zZmkR/sgO9MHHZklTfuQZa/HpelmjbX7FF+Ynxu8b22/8DU0G +AbQOXDBGVWCvOGU6yke6rCzMRh+yRpY/8+0mBe53oWprfi1tWFxK1I5nuPHa1UaK +J/kR8slC/k7e3x9cxKSGhxYzoacXGKUN5AXlK8IrC6KVkLn9YDxOiT7nnO4fuwEC +AwEAAaNCMEAwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0O +BBYEFOBNv9ybQV0T6GTwp+kVpOGBwboxMA0GCSqGSIb3DQEBCwUAA4ICAQBqinA4 +WbbaixjIvirTthnVZil6Xc1bL3McJk6jfW+rtylNpumlEYOnOXOvEESS5iVdT2H6 +yAa+Tkvv/vMx/sZ8cApBWNromUuWyXi8mHwCKe0JgOYKOoICKuLJL8hWGSbueBwj +/feTZU7n85iYr83d2Z5AiDEoOqsuC7CsDCT6eiaY8xJhEPRdF/d+4niXVOKM6Cm6 +jBAyvd0zaziGfjk9DgNyp115j0WKWa5bIW4xRtVZjc8VX90xJc/bYNaBRHIpAlf2 +ltTW/+op2znFuCyKGo3Oy+dCMYYFaA6eFN0AkLppRQjbbpCBhqcqBT/mhDn4t/lX +X0ykeVoQDF7Va/81XwVRHmyjdanPUIPTfPRm94KNPQx96N97qA4bLJyuQHCH2u2n +FoJavjVsIE4iYdm8UXrNemHcSxH5/mc0zy4EZmFcV5cjjPOGG0jfKq+nwf/Yjj4D +u9gqsPoUJbJRa4ZDhS4HIxaAjUz7tGM7zMN07RujHv41D198HRaG9Q7DlfEvr10l +O1Hm13ZBONFLAzkopR6RctR9q5czxNM+4Gm2KHmgCY0c0f9BckgG/Jou5yD5m6Le +ie2uPAmvylezkolwQOQvT8Jwg0DXJCxr5wkf09XHwQj02w47HAcLQxGEIYbpgNR1 +2KvxAmLBsX5VYc8T1yaw15zLKYs4SgsOkI26oQ== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEMDCCAxigAwIBAgIQUJRs7Bjq1ZxN1ZfvdY+grTANBgkqhkiG9w0BAQUFADCB +gjELMAkGA1UEBhMCVVMxHjAcBgNVBAsTFXd3dy54cmFtcHNlY3VyaXR5LmNvbTEk +MCIGA1UEChMbWFJhbXAgU2VjdXJpdHkgU2VydmljZXMgSW5jMS0wKwYDVQQDEyRY +UmFtcCBHbG9iYWwgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQxMTAxMTcx +NDA0WhcNMzUwMTAxMDUzNzE5WjCBgjELMAkGA1UEBhMCVVMxHjAcBgNVBAsTFXd3 +dy54cmFtcHNlY3VyaXR5LmNvbTEkMCIGA1UEChMbWFJhbXAgU2VjdXJpdHkgU2Vy +dmljZXMgSW5jMS0wKwYDVQQDEyRYUmFtcCBHbG9iYWwgQ2VydGlmaWNhdGlvbiBB +dXRob3JpdHkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCYJB69FbS6 +38eMpSe2OAtp87ZOqCwuIR1cRN8hXX4jdP5efrRKt6atH67gBhbim1vZZ3RrXYCP +KZ2GG9mcDZhtdhAoWORlsH9KmHmf4MMxfoArtYzAQDsRhtDLooY2YKTVMIJt2W7Q +DxIEM5dfT2Fa8OT5kavnHTu86M/0ay00fOJIYRyO82FEzG+gSqmUsE3a56k0enI4 +qEHMPJQRfevIpoy3hsvKMzvZPTeL+3o+hiznc9cKV6xkmxnr9A8ECIqsAxcZZPRa +JSKNNCyy9mgdEm3Tih4U2sSPpuIjhdV6Db1q4Ons7Be7QhtnqiXtRYMh/MHJfNVi +PvryxS3T/dRlAgMBAAGjgZ8wgZwwEwYJKwYBBAGCNxQCBAYeBABDAEEwCwYDVR0P +BAQDAgGGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFMZPoj0GY4QJnM5i5ASs +jVy16bYbMDYGA1UdHwQvMC0wK6ApoCeGJWh0dHA6Ly9jcmwueHJhbXBzZWN1cml0 +eS5jb20vWEdDQS5jcmwwEAYJKwYBBAGCNxUBBAMCAQEwDQYJKoZIhvcNAQEFBQAD +ggEBAJEVOQMBG2f7Shz5CmBbodpNl2L5JFMn14JkTpAuw0kbK5rc/Kh4ZzXxHfAR +vbdI4xD2Dd8/0sm2qlWkSLoC295ZLhVbO50WfUfXN+pfTXYSNrsf16GBBEYgoyxt +qZ4Bfj8pzgCT3/3JknOJiWSe5yvkHJEs0rnOfc5vMZnT5r7SHpDwCRR5XCOrTdLa +IR9NmXmd4c8nnxCbHIgNsIpkQTG4DmyQJKSbXHGPurt+HBvbaoAPIbzp26a3QPSy +i6mx5O+aGtA9aZnuqCij4Tyz8LIRnM98QObd50N9otg6tamN8jSZxNQQ4Qb9CYQQ +O+7ETPTsJ3xCwnR8gooJybQDJbw= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIDODCCAiCgAwIBAgIGIAYFFnACMA0GCSqGSIb3DQEBBQUAMDsxCzAJBgNVBAYT +AlJPMREwDwYDVQQKEwhjZXJ0U0lHTjEZMBcGA1UECxMQY2VydFNJR04gUk9PVCBD +QTAeFw0wNjA3MDQxNzIwMDRaFw0zMTA3MDQxNzIwMDRaMDsxCzAJBgNVBAYTAlJP +MREwDwYDVQQKEwhjZXJ0U0lHTjEZMBcGA1UECxMQY2VydFNJR04gUk9PVCBDQTCC +ASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALczuX7IJUqOtdu0KBuqV5Do +0SLTZLrTk+jUrIZhQGpgV2hUhE28alQCBf/fm5oqrl0Hj0rDKH/v+yv6efHHrfAQ +UySQi2bJqIirr1qjAOm+ukbuW3N7LBeCgV5iLKECZbO9xSsAfsT8AzNXDe3i+s5d +RdY4zTW2ssHQnIFKquSyAVwdj1+ZxLGt24gh65AIgoDzMKND5pCCrlUoSe1b16kQ +OA7+j0xbm0bqQfWwCHTD0IgztnzXdN/chNFDDnU5oSVAKOp4yw4sLjmdjItuFhwv +JoIQ4uNllAoEwF73XVv4EOLQunpL+943AAAaWyjj0pxzPjKHmKHJUS/X3qwzs08C +AwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAcYwHQYDVR0O +BBYEFOCMm9slSbPxfIbWskKHC9BroNnkMA0GCSqGSIb3DQEBBQUAA4IBAQA+0hyJ +LjX8+HXd5n9liPRyTMks1zJO890ZeUe9jjtbkw9QSSQTaxQGcu8J06Gh40CEyecY +MnQ8SG4Pn0vU9x7Tk4ZkVJdjclDVVc/6IJMCopvDI5NOFlV2oHB5bc0hH88vLbwZ +44gx+FkagQnIl6Z0x2DEW8xXjrJ1/RsCCdtZb3KTafcxQdaIOL+Hsr0Wefmq5L6I +Jd1hJyMctTEHBDa0GpC9oHRxUIltvBTjD4au8as+x6AJzKNI0eDbZOeStc+vckNw +i/nDhDwTqn6Sm1dTk/pwwpEOMfmbZ13pljheX7NzTogVZ96edhBiIL5VaZVDADlN +9u6wWk5JRFRYX0KD +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIFsDCCA5igAwIBAgIQFci9ZUdcr7iXAF7kBtK8nTANBgkqhkiG9w0BAQUFADBe +MQswCQYDVQQGEwJUVzEjMCEGA1UECgwaQ2h1bmdod2EgVGVsZWNvbSBDby4sIEx0 +ZC4xKjAoBgNVBAsMIWVQS0kgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAe +Fw0wNDEyMjAwMjMxMjdaFw0zNDEyMjAwMjMxMjdaMF4xCzAJBgNVBAYTAlRXMSMw +IQYDVQQKDBpDaHVuZ2h3YSBUZWxlY29tIENvLiwgTHRkLjEqMCgGA1UECwwhZVBL +SSBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIICIjANBgkqhkiG9w0BAQEF +AAOCAg8AMIICCgKCAgEA4SUP7o3biDN1Z82tH306Tm2d0y8U82N0ywEhajfqhFAH +SyZbCUNsIZ5qyNUD9WBpj8zwIuQf5/dqIjG3LBXy4P4AakP/h2XGtRrBp0xtInAh +ijHyl3SJCRImHJ7K2RKilTza6We/CKBk49ZCt0Xvl/T29de1ShUCWH2YWEtgvM3X +DZoTM1PRYfl61dd4s5oz9wCGzh1NlDivqOx4UXCKXBCDUSH3ET00hl7lSM2XgYI1 +TBnsZfZrxQWh7kcT1rMhJ5QQCtkkO7q+RBNGMD+XPNjX12ruOzjjK9SXDrkb5wdJ +fzcq+Xd4z1TtW0ado4AOkUPB1ltfFLqfpo0kR0BZv3I4sjZsN/+Z0V0OWQqraffA +sgRFelQArr5T9rXn4fg8ozHSqf4hUmTFpmfwdQcGlBSBVcYn5AGPF8Fqcde+S/uU +WH1+ETOxQvdibBjWzwloPn9s9h6PYq2lY9sJpx8iQkEeb5mKPtf5P0B6ebClAZLS +nT0IFaUQAS2zMnaolQ2zepr7BxB4EW/hj8e6DyUadCrlHJhBmd8hh+iVBmoKs2pH +dmX2Os+PYhcZewoozRrSgx4hxyy/vv9haLdnG7t4TY3OZ+XkwY63I2binZB1NJip +NiuKmpS5nezMirH4JYlcWrYvjB9teSSnUmjDhDXiZo1jDiVN1Rmy5nk3pyKdVDEC +AwEAAaNqMGgwHQYDVR0OBBYEFB4M97Zn8uGSJglFwFU5Lnc/QkqiMAwGA1UdEwQF +MAMBAf8wOQYEZyoHAAQxMC8wLQIBADAJBgUrDgMCGgUAMAcGBWcqAwAABBRFsMLH +ClZ87lt4DJX5GFPBphzYEDANBgkqhkiG9w0BAQUFAAOCAgEACbODU1kBPpVJufGB +uvl2ICO1J2B01GqZNF5sAFPZn/KmsSQHRGoqxqWOeBLoR9lYGxMqXnmbnwoqZ6Yl +PwZpVnPDimZI+ymBV3QGypzqKOg4ZyYr8dW1P2WT+DZdjo2NQCCHGervJ8A9tDkP +JXtoUHRVnAxZfVo9QZQlUgjgRywVMRnVvwdVxrsStZf0X4OFunHB2WyBEXYKCrC/ +gpf36j36+uwtqSiUO1bd0lEursC9CBWMd1I0ltabrNMdjmEPNXubrjlpC2JgQCA2 +j6/7Nu4tCEoduL+bXPjqpRugc6bY+G7gMwRfaKonh+3ZwZCc7b3jajWvY9+rGNm6 +5ulK6lCKD2GTHuItGeIwlDWSXQ62B68ZgI9HkFFLLk3dheLSClIKF5r8GrBQAuUB +o2M3IUxExJtRmREOc5wGj1QupyheRDmHVi03vYVElOEMSyycw5KFNGHLD7ibSkNS +/jQ6fbjpKdx2qcgw+BRxgMYeNkh0IkFch4LoGHGLQYlE535YW6i4jRPpp2zDR+2z +Gp1iro2C6pSe3VkQw63d4k3jMdXH7OjysP6SHhYKGvzZ8/gntsm+HbRsZJB/9OTE +W9c3rkIO3aQab3yIVMUWbuF6aC74Or8NpDyJO3inTmODBCEIZ43ygknQW/2xzQ+D +hNQ+IIX3Sj0rnP0qCglN6oH4EZw= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEIDCCAwigAwIBAgIQNE7VVyDV7exJ9C/ON9srbTANBgkqhkiG9w0BAQUFADCB +qTELMAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5jLjEoMCYGA1UECxMf +Q2VydGlmaWNhdGlvbiBTZXJ2aWNlcyBEaXZpc2lvbjE4MDYGA1UECxMvKGMpIDIw +MDYgdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxHzAdBgNV +BAMTFnRoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EwHhcNMDYxMTE3MDAwMDAwWhcNMzYw +NzE2MjM1OTU5WjCBqTELMAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5j +LjEoMCYGA1UECxMfQ2VydGlmaWNhdGlvbiBTZXJ2aWNlcyBEaXZpc2lvbjE4MDYG +A1UECxMvKGMpIDIwMDYgdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNl +IG9ubHkxHzAdBgNVBAMTFnRoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EwggEiMA0GCSqG +SIb3DQEBAQUAA4IBDwAwggEKAoIBAQCsoPD7gFnUnMekz52hWXMJEEUMDSxuaPFs +W0hoSVk3/AszGcJ3f8wQLZU0HObrTQmnHNK4yZc2AreJ1CRfBsDMRJSUjQJib+ta +3RGNKJpchJAQeg29dGYvajig4tVUROsdB58Hum/u6f1OCyn1PoSgAfGcq/gcfomk +6KHYcWUNo1F77rzSImANuVud37r8UVsLr5iy6S7pBOhih94ryNdOwUxkHt3Ph1i6 +Sk/KaAcdHJ1KxtUvkcx8cXIcxcBn6zL9yZJclNqFwJu/U30rCfSMnZEfl2pSy94J +NqR32HuHUETVPm4pafs5SSYeCaWAe0At6+gnhcn+Yf1+5nyXHdWdAgMBAAGjQjBA +MA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBR7W0XP +r87Lev0xkhpqtvNG61dIUDANBgkqhkiG9w0BAQUFAAOCAQEAeRHAS7ORtvzw6WfU +DW5FvlXok9LOAz/t2iWwHVfLHjp2oEzsUHboZHIMpKnxuIvW1oeEuzLlQRHAd9mz +YJ3rG9XRbkREqaYB7FViHXe4XI5ISXycO1cRrK1zN44veFyQaEfZYGDm/Ac9IiAX +xPcW6cTYcvnIc3zfFi8VqT79aie2oetaupgf1eNNZAqdE8hhuvU5HIe6uL17In/2 +/qxAeeWsEG89jxt5dovEN7MhGITlNgDrYyCZuen+MwS7QcjBAvlEYyCegc5C09Y/ +LHbTY5xZ3Y+m4Q6gLkH3LpVHz7z9M/P2C2F+fpErgUfCJzDupxBdN49cOSvkBPB7 +jVaMaA== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIICiDCCAg2gAwIBAgIQNfwmXNmET8k9Jj1Xm67XVjAKBggqhkjOPQQDAzCBhDEL +MAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5jLjE4MDYGA1UECxMvKGMp +IDIwMDcgdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxJDAi +BgNVBAMTG3RoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EgLSBHMjAeFw0wNzExMDUwMDAw +MDBaFw0zODAxMTgyMzU5NTlaMIGEMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMdGhh +d3RlLCBJbmMuMTgwNgYDVQQLEy8oYykgMjAwNyB0aGF3dGUsIEluYy4gLSBGb3Ig +YXV0aG9yaXplZCB1c2Ugb25seTEkMCIGA1UEAxMbdGhhd3RlIFByaW1hcnkgUm9v +dCBDQSAtIEcyMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEotWcgnuVnfFSeIf+iha/ +BebfowJPDQfGAFG6DAJSLSKkQjnE/o/qycG+1E3/n3qe4rF8mq2nhglzh9HnmuN6 +papu+7qzcMBniKI11KOasf2twu8x+qi58/sIxpHR+ymVo0IwQDAPBgNVHRMBAf8E +BTADAQH/MA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUmtgAMADna3+FGO6Lts6K +DPgR4bswCgYIKoZIzj0EAwMDaQAwZgIxAN344FdHW6fmCsO99YCKlzUNG4k8VIZ3 +KMqh9HneteY4sPBlcIx/AlTCv//YoT7ZzwIxAMSNlPzcU9LcnXgWHxUzI1NS41ox +XZ3Krr0TKUQNJ1uo52icEvdYPy5yAlejj6EULg== +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIEKjCCAxKgAwIBAgIQYAGXt0an6rS0mtZLL/eQ+zANBgkqhkiG9w0BAQsFADCB +rjELMAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5jLjEoMCYGA1UECxMf +Q2VydGlmaWNhdGlvbiBTZXJ2aWNlcyBEaXZpc2lvbjE4MDYGA1UECxMvKGMpIDIw +MDggdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxJDAiBgNV +BAMTG3RoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EgLSBHMzAeFw0wODA0MDIwMDAwMDBa +Fw0zNzEyMDEyMzU5NTlaMIGuMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMdGhhd3Rl +LCBJbmMuMSgwJgYDVQQLEx9DZXJ0aWZpY2F0aW9uIFNlcnZpY2VzIERpdmlzaW9u +MTgwNgYDVQQLEy8oYykgMjAwOCB0aGF3dGUsIEluYy4gLSBGb3IgYXV0aG9yaXpl +ZCB1c2Ugb25seTEkMCIGA1UEAxMbdGhhd3RlIFByaW1hcnkgUm9vdCBDQSAtIEcz +MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsr8nLPvb2FvdeHsbnndm +gcs+vHyu86YnmjSjaDFxODNi5PNxZnmxqWWjpYvVj2AtP0LMqmsywCPLLEHd5N/8 +YZzic7IilRFDGF/Eth9XbAoFWCLINkw6fKXRz4aviKdEAhN0cXMKQlkC+BsUa0Lf +b1+6a4KinVvnSr0eAXLbS3ToO39/fR8EtCab4LRarEc9VbjXsCZSKAExQGbY2SS9 +9irY7CFJXJv2eul/VTV+lmuNk5Mny5K76qxAwJ/C+IDPXfRa3M50hqY+bAtTyr2S +zhkGcuYMXDhpxwTWvGzOW/b3aJzcJRVIiKHpqfiYnODz1TEoYRFsZ5aNOZnLwkUk +OQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjAdBgNV +HQ4EFgQUrWyqlGCc7eT/+j4KdCtjA/e2Wb8wDQYJKoZIhvcNAQELBQADggEBABpA +2JVlrAmSicY59BDlqQ5mU1143vokkbvnRFHfxhY0Cu9qRFHqKweKA3rD6z8KLFIW +oCtDuSWQP3CpMyVtRRooOyfPqsMpQhvfO0zAMzRbQYi/aytlryjvsvXDqmbOe1bu +t8jLZ8HJnBoYuMTDSQPxYA5QzUbF83d597YV4Djbxy8ooAw/dyZ02SUS2jHaGh7c +KUGRIjxpp7sC8rZcJwOJ9Abqm+RyguOhCcHpABnTPtRwa7pxpqpYrvS76Wy274fM +m7v/OeZWYdMKp8RcTGB7BXcmer/YB1IsYvdwY9k5vG8cwnncdimvzsUsZAReiDZu +MdRAGmI0Nj81Aa6sY6A= +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIHPTCCBSWgAwIBAgIBADANBgkqhkiG9w0BAQQFADB5MRAwDgYDVQQKEwdSb290 +IENBMR4wHAYDVQQLExVodHRwOi8vd3d3LmNhY2VydC5vcmcxIjAgBgNVBAMTGUNB +IENlcnQgU2lnbmluZyBBdXRob3JpdHkxITAfBgkqhkiG9w0BCQEWEnN1cHBvcnRA +Y2FjZXJ0Lm9yZzAeFw0wMzAzMzAxMjI5NDlaFw0zMzAzMjkxMjI5NDlaMHkxEDAO +BgNVBAoTB1Jvb3QgQ0ExHjAcBgNVBAsTFWh0dHA6Ly93d3cuY2FjZXJ0Lm9yZzEi +MCAGA1UEAxMZQ0EgQ2VydCBTaWduaW5nIEF1dGhvcml0eTEhMB8GCSqGSIb3DQEJ +ARYSc3VwcG9ydEBjYWNlcnQub3JnMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIIC +CgKCAgEAziLA4kZ97DYoB1CW8qAzQIxL8TtmPzHlawI229Z89vGIj053NgVBlfkJ +8BLPRoZzYLdufujAWGSuzbCtRRcMY/pnCujW0r8+55jE8Ez64AO7NV1sId6eINm6 +zWYyN3L69wj1x81YyY7nDl7qPv4coRQKFWyGhFtkZip6qUtTefWIonvuLwphK42y +fk1WpRPs6tqSnqxEQR5YYGUFZvjARL3LlPdCfgv3ZWiYUQXw8wWRBB0bF4LsyFe7 +w2t6iPGwcswlWyCR7BYCEo8y6RcYSNDHBS4CMEK4JZwFaz+qOqfrU0j36NK2B5jc +G8Y0f3/JHIJ6BVgrCFvzOKKrF11myZjXnhCLotLddJr3cQxyYN/Nb5gznZY0dj4k +epKwDpUeb+agRThHqtdB7Uq3EvbXG4OKDy7YCbZZ16oE/9KTfWgu3YtLq1i6L43q +laegw1SJpfvbi1EinbLDvhG+LJGGi5Z4rSDTii8aP8bQUWWHIbEZAWV/RRyH9XzQ +QUxPKZgh/TMfdQwEUfoZd9vUFBzugcMd9Zi3aQaRIt0AUMyBMawSB3s42mhb5ivU +fslfrejrckzzAeVLIL+aplfKkQABi6F1ITe1Yw1nPkZPcCBnzsXWWdsC4PDSy826 +YreQQejdIOQpvGQpQsgi3Hia/0PsmBsJUUtaWsJx8cTLc6nloQsCAwEAAaOCAc4w +ggHKMB0GA1UdDgQWBBQWtTIb1Mfz4OaO873SsDrusjkY0TCBowYDVR0jBIGbMIGY +gBQWtTIb1Mfz4OaO873SsDrusjkY0aF9pHsweTEQMA4GA1UEChMHUm9vdCBDQTEe +MBwGA1UECxMVaHR0cDovL3d3dy5jYWNlcnQub3JnMSIwIAYDVQQDExlDQSBDZXJ0 +IFNpZ25pbmcgQXV0aG9yaXR5MSEwHwYJKoZIhvcNAQkBFhJzdXBwb3J0QGNhY2Vy +dC5vcmeCAQAwDwYDVR0TAQH/BAUwAwEB/zAyBgNVHR8EKzApMCegJaAjhiFodHRw +czovL3d3dy5jYWNlcnQub3JnL3Jldm9rZS5jcmwwMAYJYIZIAYb4QgEEBCMWIWh0 +dHBzOi8vd3d3LmNhY2VydC5vcmcvcmV2b2tlLmNybDA0BglghkgBhvhCAQgEJxYl +aHR0cDovL3d3dy5jYWNlcnQub3JnL2luZGV4LnBocD9pZD0xMDBWBglghkgBhvhC +AQ0ESRZHVG8gZ2V0IHlvdXIgb3duIGNlcnRpZmljYXRlIGZvciBGUkVFIGhlYWQg +b3ZlciB0byBodHRwOi8vd3d3LmNhY2VydC5vcmcwDQYJKoZIhvcNAQEEBQADggIB +ACjH7pyCArpcgBLKNQodgW+JapnM8mgPf6fhjViVPr3yBsOQWqy1YPaZQwGjiHCc +nWKdpIevZ1gNMDY75q1I08t0AoZxPuIrA2jxNGJARjtT6ij0rPtmlVOKTV39O9lg +18p5aTuxZZKmxoGCXJzN600BiqXfEVWqFcofN8CCmHBh22p8lqOOLlQ+TyGpkO/c +gr/c6EWtTZBzCDyUZbAEmXZ/4rzCahWqlwQ3JNgelE5tDlG+1sSPypZt90Pf6DBl +Jzt7u0NDY8RD97LsaMzhGY4i+5jhe1o+ATc7iwiwovOVThrLm82asduycPAtStvY +sONvRUgzEv/+PDIqVPfE94rwiCPCR/5kenHA0R6mY7AHfqQv0wGP3J8rtsYIqQ+T +SCX8Ev2fQtzzxD72V7DX3WnRBnc0CkvSyqD/HMaMyRa+xMwyN2hzXwj7UfdJUzYF +CpUCTPJ5GhD22Dp1nPMd8aINcGeGG7MW9S/lpOt5hvk9C8JzC6WZrG/8Z7jlLwum +GCSNe9FINSkYQKyTYOGWhlC0elnYjyELn8+CkcY7v2vcB5G5l1YjqrZslMZIBjzk +zk6q5PYvCdxTby78dOs6Y5nCpqyJvKeyRKANihDjbPIky/qbn3BHLt4Ui9SyIAmW +omTxJBzcoTWcFbLUvFUufQb1nA5V9FrWk9p2rSVzTMVD +-----END CERTIFICATE----- +-----BEGIN CERTIFICATE----- +MIIHWTCCBUGgAwIBAgIDCkGKMA0GCSqGSIb3DQEBCwUAMHkxEDAOBgNVBAoTB1Jv +b3QgQ0ExHjAcBgNVBAsTFWh0dHA6Ly93d3cuY2FjZXJ0Lm9yZzEiMCAGA1UEAxMZ +Q0EgQ2VydCBTaWduaW5nIEF1dGhvcml0eTEhMB8GCSqGSIb3DQEJARYSc3VwcG9y +dEBjYWNlcnQub3JnMB4XDTExMDUyMzE3NDgwMloXDTIxMDUyMDE3NDgwMlowVDEU +MBIGA1UEChMLQ0FjZXJ0IEluYy4xHjAcBgNVBAsTFWh0dHA6Ly93d3cuQ0FjZXJ0 +Lm9yZzEcMBoGA1UEAxMTQ0FjZXJ0IENsYXNzIDMgUm9vdDCCAiIwDQYJKoZIhvcN +AQEBBQADggIPADCCAgoCggIBAKtJNRFIfNImflOUz0Op3SjXQiqL84d4GVh8D57a +iX3h++tykA10oZZkq5+gJJlz2uJVdscXe/UErEa4w75/ZI0QbCTzYZzA8pD6Ueb1 +aQFjww9W4kpCz+JEjCUoqMV5CX1GuYrz6fM0KQhF5Byfy5QEHIGoFLOYZcRD7E6C +jQnRvapbjZLQ7N6QxX8KwuPr5jFaXnQ+lzNZ6MMDPWAzv/fRb0fEze5ig1JuLgia +pNkVGJGmhZJHsK5I6223IeyFGmhyNav/8BBdwPSUp2rVO5J+TJAFfpPBLIukjmJ0 +FXFuC3ED6q8VOJrU0gVyb4z5K+taciX5OUbjchs+BMNkJyIQKopPWKcDrb60LhPt +XapI19V91Cp7XPpGBFDkzA5CW4zt2/LP/JaT4NsRNlRiNDiPDGCbO5dWOK3z0luL +oFvqTpa4fNfVoIZwQNORKbeiPK31jLvPGpKK5DR7wNhsX+kKwsOnIJpa3yxdUly6 +R9Wb7yQocDggL9V/KcCyQQNokszgnMyXS0XvOhAKq3A6mJVwrTWx6oUrpByAITGp +rmB6gCZIALgBwJNjVSKRPFbnr9s6JfOPMVTqJouBWfmh0VMRxXudA/Z0EeBtsSw/ +LIaRmXGapneLNGDRFLQsrJ2vjBDTn8Rq+G8T/HNZ92ZCdB6K4/jc0m+YnMtHmJVA +BfvpAgMBAAGjggINMIICCTAdBgNVHQ4EFgQUdahxYEyIE/B42Yl3tW3Fid+8sXow +gaMGA1UdIwSBmzCBmIAUFrUyG9TH8+DmjvO90rA67rI5GNGhfaR7MHkxEDAOBgNV +BAoTB1Jvb3QgQ0ExHjAcBgNVBAsTFWh0dHA6Ly93d3cuY2FjZXJ0Lm9yZzEiMCAG +A1UEAxMZQ0EgQ2VydCBTaWduaW5nIEF1dGhvcml0eTEhMB8GCSqGSIb3DQEJARYS +c3VwcG9ydEBjYWNlcnQub3JnggEAMA8GA1UdEwEB/wQFMAMBAf8wXQYIKwYBBQUH +AQEEUTBPMCMGCCsGAQUFBzABhhdodHRwOi8vb2NzcC5DQWNlcnQub3JnLzAoBggr +BgEFBQcwAoYcaHR0cDovL3d3dy5DQWNlcnQub3JnL2NhLmNydDBKBgNVHSAEQzBB +MD8GCCsGAQQBgZBKMDMwMQYIKwYBBQUHAgEWJWh0dHA6Ly93d3cuQ0FjZXJ0Lm9y +Zy9pbmRleC5waHA/aWQ9MTAwNAYJYIZIAYb4QgEIBCcWJWh0dHA6Ly93d3cuQ0Fj +ZXJ0Lm9yZy9pbmRleC5waHA/aWQ9MTAwUAYJYIZIAYb4QgENBEMWQVRvIGdldCB5 +b3VyIG93biBjZXJ0aWZpY2F0ZSBmb3IgRlJFRSwgZ28gdG8gaHR0cDovL3d3dy5D +QWNlcnQub3JnMA0GCSqGSIb3DQEBCwUAA4ICAQApKIWuRKm5r6R5E/CooyuXYPNc +7uMvwfbiZqARrjY3OnYVBFPqQvX56sAV2KaC2eRhrnILKVyQQ+hBsuF32wITRHhH +Va9Y/MyY9kW50SD42CEH/m2qc9SzxgfpCYXMO/K2viwcJdVxjDm1Luq+GIG6sJO4 +D+Pm1yaMMVpyA4RS5qb1MyJFCsgLDYq4Nm+QCaGrvdfVTi5xotSu+qdUK+s1jVq3 +VIgv7nSf7UgWyg1I0JTTrKSi9iTfkuO960NAkW4cGI5WtIIS86mTn9S8nK2cde5a +lxuV53QtHA+wLJef+6kzOXrnAzqSjiL2jA3k2X4Ndhj3AfnvlpaiVXPAPHG0HRpW +Q7fDCo1y/OIQCQtBzoyUoPkD/XFzS4pXM+WOdH4VAQDmzEoc53+VGS3FpQyLu7Xt +hbNc09+4ufLKxw0BFKxwWMWMjTPUnWajGlCVI/xI4AZDEtnNp4Y5LzZyo4AQ5OHz +0ctbGsDkgJp8E3MGT9ujayQKurMcvEp4u+XjdTilSKeiHq921F73OIZWWonO1sOn +ebJSoMbxhbQljPI/lrMQ2Y1sVzufb4Y6GIIiNsiwkTjbKqGTqoQ/9SdlrnPVyNXT +d+pLncdBu8fA46A/5H2kjXPmEkvfoXNzczqA6NXLji/L6hOn1kGLrPo8idck9U60 +4GGSt/M3mMS+lqO3ig== +-----END CERTIFICATE----- diff --git a/librest/rest.c b/librest/rest.c index 014f1d6..6939f21 100644 --- a/librest/rest.c +++ b/librest/rest.c @@ -102,10 +102,13 @@ char * rest_escape(char * url){ void * run_curl(void* ptr){ if (ptr != NULL){ run_curl_args * args = (run_curl_args*) ptr; - curl_easy_perform(args->curl); - curl_easy_cleanup(args->curl); + CURLcode res = curl_easy_perform(args->curl); + if (res != CURLE_OK){ + printf("rest_get error: %s\n", curl_easy_strerror(res)); + } fclose(args->file); free(args->url); + curl_easy_cleanup(args->curl); } return NULL; } @@ -204,10 +207,11 @@ buffer rest_get_buffer (char ** params, char * url){ CURLcode res = curl_easy_perform(curl); if (res != CURLE_OK){ //TODO: return better error handling; + printf("rest_get_buffer error: %s\n", curl_easy_strerror(res)); //printf("code = %d, data= %s\n",res,data.data); } - curl_easy_cleanup(curl); free(full_url); + curl_easy_cleanup(curl); return data; } @@ -223,11 +227,12 @@ buffer rest_post (char ** params, char * url){ curl_easy_setopt(curl,CURLOPT_WRITEDATA, &data); curl_easy_setopt(curl,CURLOPT_WRITEFUNCTION,WriteBufferCB); CURLcode res = curl_easy_perform(curl); - if (res != CURLE_OK) - //printf("res = %d, data = %s\n",res,data.data); - curl_easy_cleanup(curl); + if (res != CURLE_OK){ + printf("rest_post error: %s\n", curl_easy_strerror(res)); + } free(post); free(escaped_url); + curl_easy_cleanup(curl); return data; } @@ -250,12 +255,13 @@ buffer rest_post_headers (char ** params, char ** headers, char * url){ CURLcode res = curl_easy_perform(curl); if (res != CURLE_OK){ //TODO: better error handling - //printf("res = &d, data = %s\n",res,data.data); + printf("rest_post_headers error: %s\n", curl_easy_strerror(res)); } - curl_easy_cleanup(curl); - curl_slist_free_all(slist); - free(--post); + post++; + free(post); free(escaped_url); + curl_slist_free_all(slist); + curl_easy_cleanup(curl); return data; } @@ -309,11 +315,14 @@ int rest_post_all(rest_args args){ } //curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L); CURLcode res = curl_easy_perform(curl); - curl_easy_cleanup(curl); + if (res != CURLE_OK){ + printf("rest_post_all error: %s\n", curl_easy_strerror(res)); + } free(post); free(content_type); free(escaped_url); curl_slist_free_all(slist); + curl_easy_cleanup(curl); return res; } @@ -367,10 +376,13 @@ int rest_put_all(rest_args args, FILE * file){ //curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L); CURLcode res = curl_easy_perform(curl); - curl_easy_cleanup(curl); + if (res != CURLE_OK){ + printf("rest_post_all error: %s\n", curl_easy_strerror(res)); + } free(content_type); free(full_url); curl_slist_free_all(slist); + curl_easy_cleanup(curl); return res; } @@ -389,11 +401,12 @@ buffer rest_put_file (char** params, char* url, FILE * in){ curl_easy_setopt(curl,CURLOPT_READFUNCTION,ReadFileCB); // for windows CURLcode res = curl_easy_perform(curl); free(full_url); - curl_easy_cleanup(curl); if (res != CURLE_OK){ //printf("res = %d, data = %.*s\n",res,(int)data.size,data.data); + printf("rest_put_file error: %s\n", curl_easy_strerror(res)); data = buffer_free(data); } + curl_easy_cleanup(curl); return data; } @@ -422,10 +435,11 @@ buffer rest_put_headers (char** params,char** headers, char* url, FILE * in){ CURLcode res = curl_easy_perform(curl); free(full_url); curl_slist_free_all(slist); - curl_easy_cleanup(curl); if (res != CURLE_OK){ + printf("rest_put_headers error: %s\n", curl_easy_strerror(res)); //printf("res = %d, data = %.*s\n",res,(int)data.size,data.data); data = buffer_free(data); } + curl_easy_cleanup(curl); return data; } diff --git a/src/cache.c b/src/cache.c index 84d61d1..f7e82b1 100644 --- a/src/cache.c +++ b/src/cache.c @@ -32,6 +32,7 @@ #include "shared_memory.h" #include "log.h" #include +#include #ifndef MAP_FILE #define MAP_FILE 0 @@ -76,15 +77,17 @@ void cache_init(){ PROT_READ | PROT_WRITE, MAP_FILE|MAP_SHARED, cacheFD, 0); if (cacheFile == MAP_FAILED ) errx(1,"failed"); // setup semaphores. - cache_semaphore = semaphore_create(1, "SYNCD\\cache"); + cache_semaphore = semaphore_create(1, "SYNCD\\cache" ); config_semaphore = semaphore_create(1, "SYNCD\\config"); } void cache_clear(){ munmap(cacheFile, *cacheLength); close(cacheFD); - semaphore_delete(cache_semaphore, "SYNCD\\cache"); - semaphore_delete(config_semaphore, "SYNCD\\cache"); + json_object_put(config); + json_object_put(cache); + semaphore_delete(cache_semaphore , "SYNCD\\cache" ); + semaphore_delete(config_semaphore, "SYNCD\\config"); } json_object * getCache(const char * plugin_prefix){ @@ -107,7 +110,7 @@ json_object * getFileCache(const char * plugin_prefix,const char * fname){ logging_log(LOGARGS,"%s\n",json_object_to_json_string(fcache)); return fcache; } else { - logging_log(LOGARGS," failure\n"); + logging_log(LOGARGS," cache miss.\n"); return NULL; } } @@ -123,6 +126,7 @@ json_object * getConfig(const char * plugin_prefix){ } void addCache(const char * plugin_prefix, const char * fname, json_object * entry){ + printf("addCache: Refcount = %d\n", entry->_ref_count); json_object * cache_entry = json_object_get(entry); json_object * pcache = getCache(plugin_prefix); if (pcache == NULL){/* create cache for plugin*/ @@ -130,12 +134,16 @@ void addCache(const char * plugin_prefix, const char * fname, json_object * entr json_object_object_add(cache, plugin_prefix, pcache); } if (fname != NULL && strlen(fname) != 0 && cache_entry != NULL){ + if (json_object_object_get_ex(pcache, fname, NULL)){ + json_object_object_del(pcache, fname); + } json_object_object_add(pcache, fname, cache_entry); push_cache(); } else { - logging_log(LOGARGS,"addaCache Failed: fname = %s; cache_entry = %s\n",fname,json_object_to_json_string(cache_entry)); + printf("addCache Failed: fname = %s; cache_entry = %s\n",fname,json_object_to_json_string(cache_entry)); } json_object_put(cache_entry); + printf("addCache: Refcount = %d\n", entry->_ref_count); } void updateCache(const char * plugin_prefix, json_object * pcache){ diff --git a/src/json_helper.c b/src/json_helper.c index 2fc94d9..bd37f4f 100644 --- a/src/json_helper.c +++ b/src/json_helper.c @@ -23,15 +23,13 @@ #include /* Utilities */ -json_object * json_copy(json_object ** to_ptr, const char * name, json_object * from, json_object * def) { - json_object * obj; - json_object * to = * to_ptr; - if (json_object_object_get_ex(from, name, &obj)){ - json_object_object_add(to,name,obj); - } else { - json_object_object_add(to,name,def); +json_object * json_copy(json_object * from, bool deep) { + if (!deep){ + return json_object_get(from); } - return to; + return json_tokener_parse( + json_object_to_json_string(from) + ); } /* Getters */ diff --git a/src/json_helper.h b/src/json_helper.h index ee2fbc2..cc7a694 100644 --- a/src/json_helper.h +++ b/src/json_helper.h @@ -47,7 +47,7 @@ struct JSON_HELPER { }; typedef struct JSON_HELPER JSON_HELPER; -json_object * json_copy(json_object **, const char *, json_object *, json_object *); +json_object * json_copy(json_object * from, bool deep); const char * json_get_string(json_object * obj, const char * name); long long int json_get_int(json_object * obj, const char * name, long long int def); diff --git a/src/log.c b/src/log.c index f551479..c646bd6 100644 --- a/src/log.c +++ b/src/log.c @@ -63,6 +63,6 @@ void logging_close() dup2(__stdout_fd, fileno(stdout)); dup2(__stderr_fd, fileno(stderr)); - close(__stderr_fd); - close(__stdout_fd); + fclose(__stderr); + fclose(__stdout); } diff --git a/src/syncd.c b/src/syncd.c index e6e29af..8b71999 100644 --- a/src/syncd.c +++ b/src/syncd.c @@ -88,15 +88,6 @@ json_object * rules; #define fork() pseudo_fork(i,argv[0]) #endif -json_object * getCacheDetails(int pnum, const char * path) { - const char * plugin_prefix = plugins[pnum].prefix; - json_object * foc = getFileCache(plugin_prefix,path +strlen(plugin_prefix)); - json_object * details = json_object_new_object(); - json_copy(&details,"size",foc, json_object_new_int64(0)); - json_copy(&details, "modified", foc,json_object_new_int64(0)); - return details; -} - char ** free_all(char ** array, int length){ int i; if (array == NULL) length = 0; @@ -175,20 +166,30 @@ int cb(const char * path, int mask){ int pd = get_plugin(sync_path[i]); const char * dest_prefix = plugins[pd].prefix; - json_object * dest_cache = getFileCache(dest_prefix, sync_path[i] + strlen(dest_prefix)); - if (dest_cache == NULL) dest_cache = json_object_new_object(); + + json_object * dest_cache; + { + dest_cache = json_copy( + getFileCache(dest_prefix, sync_path[i] + strlen(dest_prefix)), + false + ); + if (dest_cache == NULL) dest_cache = json_object_new_object(); + } + long long int orig_ver = json_get_int(orig_cache, "version",0); logging_log(LOGARGS,"original version = %lld;",orig_ver); - if ( json_get_int(dest_cache, "version", -1) >= orig_ver){ + if ( json_get_int(dest_cache, "version", -1) >= orig_ver ){ logging_log(LOGARGS,"destination version = %lld\n",json_get_int(dest_cache, "version",-1)); // this file is already in sync + json_object_put(dest_cache); continue; } else { //updateFileCache(plugins[pd].prefix, sync_path[i] + strlen(plugins[pd].prefix),orig_detail); json_object_object_add(dest_cache, "next_version", json_object_new_int64(orig_ver)); addCache(dest_prefix, sync_path[i] + strlen(dest_prefix),json_object_get(dest_cache)); } + if ((mask & S_CREATE ) && (mask & S_DIR)){ logging_log(LOGARGS,"new dir\n"); S_MKDIR sync_mkdir = (S_MKDIR) lt_dlsym(plugins[pd].ptr,"sync_mkdir"); @@ -216,6 +217,7 @@ int cb(const char * path, int mask){ S_MV sync_mv = (S_MV) lt_dlsym(plugins[pd].ptr,"sync_mv"); logging_log(LOGARGS,"moved file %s to %s, returned %d\n",moved_from[i],sync_path[i],sync_mv(moved_from[i],sync_path[i])); } + json_object_put(dest_cache); } if (mask & S_MOVED_TO) moved_from = free_all(moved_from,num_moved_from); sync_path = free_all(sync_path,num_paths); @@ -225,6 +227,7 @@ int cb(const char * path, int mask){ lt_dlhandle loadPlugin(const char * filename ){ const char * ext = strrchr(filename, '.'); + if (ext == NULL) return NULL; // this cannot be a proper plugin name if(strcmp(ext, PLUGIN_EXT) != 0) return NULL; lt_dlhandle out = lt_dlopen(filename); const char * (*get_prefix)() = (const char * (*)()) lt_dlsym (out, "get_prefix"); @@ -248,6 +251,7 @@ lt_dlhandle loadPlugin(const char * filename ){ } logging_log(LOGARGS, "Not loading %.*s plugin from '%s' because it is not referenced in any rule\n", strlen(prefix)-3, prefix, filename); } + lt_dlclose(out); return NULL; } @@ -264,7 +268,7 @@ int loadPlugins(Plugin **return_plugins){ DIR * dp; struct dirent *ep; logging_log(LOGARGS,"looking for plugins in %s\n", LIBDIR ); - dp = opendir(LIBDIR ); //TODO this should pull from config.h + dp = opendir(LIBDIR ); char configPath[PATH_MAX]; strcpy(configPath, getenv("HOME")); strcat(configPath, "/.config/syncd"); @@ -302,6 +306,7 @@ void unloadPlugins(Plugin *plugins, int num){ for (i = 0; i < num; i++){ S_UNLOAD sync_unload = (S_UNLOAD) lt_dlsym(plugins[i].ptr,"sync_unload"); if (sync_unload != NULL) sync_unload(); + lt_dlclose(plugins[i].ptr); } free(plugins); lt_dlexit(); @@ -351,7 +356,7 @@ void setupConfig(){ int main(int argc, char** argv){ //LTDL_SET_PRELOADED_SYMBOLS(); lt_dlinit(); - int plugin_to_run = -1; + int plugin_to_run = -128; { int opt; while (( opt = getopt(argc,argv,"p:")) != -1){ @@ -368,7 +373,7 @@ int main(int argc, char** argv){ num_plugins = loadPlugins(&plugins); logging_stdout("got plugins\n"); int i; - if (plugin_to_run != -1){ + if (plugin_to_run > -1 && plugin_to_run < num_plugins){ S_LISTEN listen =(S_LISTEN) lt_dlsym(plugins[plugin_to_run].ptr,"sync_listen"); json_object_object_foreach(rules,dir,val){ if (get_plugin(dir) == plugin_to_run){// get rules specific to this plugin @@ -377,20 +382,24 @@ int main(int argc, char** argv){ } } listen(cb); - } else for ( i = 0; i < num_plugins; i++){ - S_LISTEN listen =(S_LISTEN) lt_dlsym(plugins[i].ptr,"sync_listen"); - int pid = fork(); - if (pid == 0){ // child - json_object_object_foreach(rules,dir,val){ - if (get_plugin(dir) == i){ // get rules specific to this plugin - logging_log(LOGARGS,"dir=%s\n",dir); - add_watch(dir); + } else if (plugin_to_run == -128){ + for ( i = 0; i < num_plugins; i++){ + S_LISTEN listen =(S_LISTEN) lt_dlsym(plugins[i].ptr,"sync_listen"); + int pid = fork(); + if (pid == 0){ // child + json_object_object_foreach(rules,dir,val){ + if (get_plugin(dir) == i){ // get rules specific to this plugin + logging_log(LOGARGS,"dir=%s\n",dir); + add_watch(dir); + } } - } - listen(cb); - exit(0); + listen(cb); + } } } + + // cleanup unloadPlugins(plugins,num_plugins); cache_clear(); + json_object_put(rules); } From dc3c9a869c07ccc4a88e050ac49836ae469f381d Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Fri, 26 Jun 2015 16:36:24 -0400 Subject: [PATCH 16/49] Windows improvements --- librest/rest.c | 6 +++++- src/cache.c | 14 +++++++------- src/log.c | 4 +++- 3 files changed, 15 insertions(+), 9 deletions(-) diff --git a/librest/rest.c b/librest/rest.c index 6939f21..00fa89b 100644 --- a/librest/rest.c +++ b/librest/rest.c @@ -31,7 +31,11 @@ #include #include #define pipe(fds) _pipe(fds,4096, _O_BINARY) - #define SSL_CERT char SSL_CA_PATH[PATH_MAX]; getcwd(SSL_CA_PATH,PATH_MAX); strcat(SSL_CA_PATH,"\\ca-bundle.crt"); curl_easy_setopt(curl, CURLOPT_CAINFO, SSL_CA_PATH); //printf("SSL_CA_PATH = '%s'\n",SSL_CA_PATH); + #define SSL_CERT char SSL_CA_PATH[PATH_MAX]; \ + GetModuleFileName(NULL, SSL_CA_PATH, PATH_MAX);\ + dirname(SSL_CA_PATH); \ + strcat(SSL_CA_PATH,"\\ca-bundle.crt"); \ + curl_easy_setopt(curl, CURLOPT_CAINFO, SSL_CA_PATH); printf("SSL_CA_PATH = '%s'\n",SSL_CA_PATH); #else #define SSL_CERT // #define SSL_CERT curl_easy_setopt(curl, CURLOPT_CAPATH, "./ca-bundle.crt"); diff --git a/src/cache.c b/src/cache.c index f7e82b1..46e7237 100644 --- a/src/cache.c +++ b/src/cache.c @@ -52,7 +52,7 @@ json_object * config; char * cacheFile; int cacheFD; long long int * cacheVersion; -size_t * cacheLength; +size_t cacheLength; semaphore cache_semaphore; semaphore config_semaphore; @@ -65,15 +65,15 @@ void push_cache(); /* public functions */ void cache_init(){ //set up shared memory - cacheLength = (size_t *) shared_mem_alloc(sizeof(size_t), "SYNCD\\cache_length"); - * cacheLength = 10 * 1024 * 1024; // 10 MB for now. + //cacheLength = (size_t *) shared_mem_alloc(sizeof(size_t), "SYNCD\\cache_length"); + cacheLength = 10 * 1024 * 1024; // 10 MB for now. char path[PATH_MAX]; strcpy(path, getenv("HOME")); strcat(path, "/.cache/syncd/cache.json"); int cacheFD = open(path,O_CREAT|O_RDWR, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP); - ftruncate(cacheFD,*cacheLength); + ftruncate(cacheFD,cacheLength); logging_log(LOGARGS,"fd = %d\n",cacheFD); - cacheFile = (char *) mmap(NULL, *cacheLength, + cacheFile = (char *) mmap(NULL, cacheLength, PROT_READ | PROT_WRITE, MAP_FILE|MAP_SHARED, cacheFD, 0); if (cacheFile == MAP_FAILED ) errx(1,"failed"); // setup semaphores. @@ -82,7 +82,7 @@ void cache_init(){ } void cache_clear(){ - munmap(cacheFile, *cacheLength); + munmap(cacheFile, cacheLength); close(cacheFD); json_object_put(config); json_object_put(cache); @@ -223,7 +223,7 @@ void push_cache(){ const char * string = ""; if (cache != NULL ) string = json_object_to_json_string(cache); logging_log(LOGARGS,"cache.json length = %d\n",(int)strlen(string)); - if (strlen(string) > *cacheLength){ + if (strlen(string) > cacheLength){ logging_log(LOGARGS,"the string is too long\n"); } semaphore_wait(cache_semaphore); diff --git a/src/log.c b/src/log.c index c646bd6..3746883 100644 --- a/src/log.c +++ b/src/log.c @@ -45,6 +45,7 @@ void logging_stdout(const char * fmt, ...) va_start(args, fmt); //vdprintf (__stdout_fd, fmt, args); vfprintf (__stdout, fmt, args); + fflush (__stdout); va_end(args); } @@ -53,7 +54,8 @@ void logging_stderr(const char * fmt, ...) va_list args; va_start(args, fmt); //vdprintf (__stdout_fd, fmt, args); - vfprintf (__stdout, fmt, args); + vfprintf (__stderr, fmt, args); + fflush (__stderr); va_end(args); } From fee7faa74e23d79386dbb830887312a0aa7d53cb Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Sat, 11 Jul 2015 00:47:14 -0400 Subject: [PATCH 17/49] fixed some memory errors related to google drive uploads --- libexec/gdrive.c | 10 ++++++---- libexec/linuxfs.c | 4 ++-- libexec/syncfs.c | 4 ++-- libexec/syncfs.h | 4 ++-- libexec/uvfs.c | 4 ++-- src/syncd.c | 2 +- 6 files changed, 15 insertions(+), 13 deletions(-) diff --git a/libexec/gdrive.c b/libexec/gdrive.c index 573b159..8e2da72 100644 --- a/libexec/gdrive.c +++ b/libexec/gdrive.c @@ -162,8 +162,9 @@ unsigned long upload(const char * path, FILE * file){ id = strdup(json_get_string(response, "id")); json_object * cache_entry = update_metadata(id, response); json_add_string(cache_entry, "path", path); - utils.updateFileCache(PLUGIN_PREFIX, id, json_object_get(cache_entry)); - utils.updateFileCache(PLUGIN_PREFIX, path, cache_entry); + utils.addCache(PLUGIN_PREFIX, id, json_object_get(cache_entry)); + utils.addCache(PLUGIN_PREFIX, path, json_object_get(cache_entry)); + json_object_put(cache_entry); json_object_put(response); free(id); free(parentID); @@ -205,8 +206,9 @@ char * mkdirP(const char * path){ json_object_put(metadata); json_object * cache_entry = update_metadata(id, response); json_add_string(cache_entry, "path", path); - utils.updateFileCache(PLUGIN_PREFIX, id, json_object_get(cache_entry)); - utils.updateFileCache(PLUGIN_PREFIX, path, cache_entry); + utils.addCache(PLUGIN_PREFIX, id, json_object_get(cache_entry)); + utils.addCache(PLUGIN_PREFIX, path, json_object_get(cache_entry)); + json_object_put(cache_entry); json_object_put(response); free(parentID); free(local_path); diff --git a/libexec/linuxfs.c b/libexec/linuxfs.c index cb904f9..6370590 100644 --- a/libexec/linuxfs.c +++ b/libexec/linuxfs.c @@ -30,7 +30,7 @@ static int watchpoints_size; #define EVENT_SIZE (sizeof(struct inotify_event)) #define EVENT_BUF_LEN (1024 * (EVENT_SIZE + 16)) -void add_watch(char * dir){ +void fs_add_watch(char * dir){ int wp = inotify_add_watch( inotify_fd, dir, IN_CREATE | IN_DELETE | IN_CLOSE_WRITE | IN_MOVE); args.log(LOGARGS,"adding directory: %s, wp = %d\n",dir,wp); char * dir_local = strdup(dir); @@ -77,7 +77,7 @@ void sync_listen(int (*cb)( const char*,int)){ update_file_cache(filename,1); if ((event->mask & IN_CREATE) && (event->mask & IN_ISDIR)){ // new directory created args.log(LOGARGS,"%.4x = %.4x\n",event->mask, (IN_CREATE|IN_ISDIR)); - add_watch(fp + PLUGIN_PREFIX_LEN); + fs_add_watch(fp + PLUGIN_PREFIX_LEN); } if (cb != NULL) cb(fp,event->mask); free(fp); diff --git a/libexec/syncfs.c b/libexec/syncfs.c index c298841..4de9798 100644 --- a/libexec/syncfs.c +++ b/libexec/syncfs.c @@ -89,7 +89,7 @@ void watch_dir_recurse(char * dir_name){ return; // exit (EXIT_FAILURE); } - add_watch(dir_name); + fs_add_watch(dir_name); while (1) { struct dirent * entry; const char * d_name; @@ -141,7 +141,7 @@ void watch_dir_recurse(char * dir_name){ } } -void watch_dir (char * dir_name){ +void sync_watch_dir (char * dir_name){ args.log(LOGARGS, "syncFS:watch_dir(%s)\n", dir_name); sync_mkdir(dir_name); dir_name += PLUGIN_PREFIX_LEN; diff --git a/libexec/syncfs.h b/libexec/syncfs.h index 419e424..dacb1ee 100644 --- a/libexec/syncfs.h +++ b/libexec/syncfs.h @@ -35,8 +35,8 @@ init_args args; //Prototypes -void add_watch(char *); -void watch_dir(char *); +void fs_add_watch(char *); +void sync_watch_dir(char *); void sync_listen(int(*)(const char*,int)); int sync_mkdir(char*); int update_file_cache(char*,int); diff --git a/libexec/uvfs.c b/libexec/uvfs.c index bf09945..222dc95 100644 --- a/libexec/uvfs.c +++ b/libexec/uvfs.c @@ -37,14 +37,14 @@ void uvfs_updates(uv_fs_event_t *handle, const char *filename, int events, int s printf("mask = %X\n",mask); if (mask & (S_DIR|S_CREATE|S_CLOSE_WRITE) ){ printf("adding new directory '%s'",fullname+PLUGIN_PREFIX_LEN); - watch_dir(fullname + PLUGIN_PREFIX_LEN); + sync_watch_dir(fullname + PLUGIN_PREFIX_LEN); } update_event(fullname, mask); } free(fullname); } -void add_watch(char * dir_name){ +void fs_add_watch(char * dir_name){ uv_fs_event_t *fs_event_req = malloc(sizeof(uv_fs_event_t)); fs_event_req->data = strdup(dir_name); uv_fs_event_init(loop, fs_event_req); diff --git a/src/syncd.c b/src/syncd.c index 8b71999..4338a28 100644 --- a/src/syncd.c +++ b/src/syncd.c @@ -317,7 +317,7 @@ void add_watch(char* path){ int p = get_plugin(path); logging_log(LOGARGS,"plugin for '%s' is %d\n",path,p); if (p != -1){ - S_WATCH_DIR watch_dir = (S_WATCH_DIR) lt_dlsym(plugins[p].ptr,"watch_dir"); + S_WATCH_DIR watch_dir = (S_WATCH_DIR) lt_dlsym(plugins[p].ptr,"sync_watch_dir"); watch_dir(path); } } From 812b05a4c6ed8a3aef370de2e660f25ba7e8876e Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 3 Sep 2015 09:37:04 -0400 Subject: [PATCH 18/49] Create .travis.yml --- .travis.yml | 8 ++++++++ 1 file changed, 8 insertions(+) create mode 100644 .travis.yml diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 0000000..bfbf965 --- /dev/null +++ b/.travis.yml @@ -0,0 +1,8 @@ +language: c + +stript: + - mkdir -p build + - cd build + - cmake .. + - make + - sudo make install From 7aa3314bc759abc638787bcab2e3d11646d497d0 Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 3 Sep 2015 09:42:54 -0400 Subject: [PATCH 19/49] Update .travis.yml --- .travis.yml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.travis.yml b/.travis.yml index bfbf965..a030e9f 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,5 +1,9 @@ language: c +compiler: + - gcc + - clang + stript: - mkdir -p build - cd build From 157984bbbac530512b7b7a7b44385f4b2f643768 Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 3 Sep 2015 09:43:50 -0400 Subject: [PATCH 20/49] Update .travis.yml --- .travis.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.travis.yml b/.travis.yml index a030e9f..d8be96b 100644 --- a/.travis.yml +++ b/.travis.yml @@ -5,6 +5,7 @@ compiler: - clang stript: + - ./autogen.sh - mkdir -p build - cd build - cmake .. From 212c9bf0ce9d46760d2e84d5496e5a29dcab6f47 Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 3 Sep 2015 09:44:42 -0400 Subject: [PATCH 21/49] Update .travis.yml --- .travis.yml | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index d8be96b..17321de 100644 --- a/.travis.yml +++ b/.travis.yml @@ -4,8 +4,7 @@ compiler: - gcc - clang -stript: - - ./autogen.sh +script: - mkdir -p build - cd build - cmake .. From b20c2b0371db43439060cd6434d9be9f0a0a0e53 Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 3 Sep 2015 09:47:58 -0400 Subject: [PATCH 22/49] Update .travis.yml --- .travis.yml | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/.travis.yml b/.travis.yml index 17321de..a517579 100644 --- a/.travis.yml +++ b/.travis.yml @@ -4,9 +4,11 @@ compiler: - gcc - clang -script: - - mkdir -p build - - cd build - - cmake .. - - make - - sudo make install +#script: +# - mkdir -p build +# - cd build +# - cmake .. +# - make +# - sudo make install + +script: ./autogen.sh && ./configure && make From 11ce154d5f5d15502a7922b199b6ad78ff3d7b7d Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 3 Sep 2015 09:52:38 -0400 Subject: [PATCH 23/49] Update .travis.yml --- .travis.yml | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/.travis.yml b/.travis.yml index a517579..e368c59 100644 --- a/.travis.yml +++ b/.travis.yml @@ -3,12 +3,15 @@ language: c compiler: - gcc - clang + +install: + - sudo apt-get install -y libjson-c-dev libcurl4-gnutls-dev libltdl-dev -#script: -# - mkdir -p build -# - cd build -# - cmake .. -# - make -# - sudo make install +script: + - mkdir -p build + - cd build + - cmake .. + - make + - sudo make install -script: ./autogen.sh && ./configure && make +#script: ./autogen.sh && ./configure && make From 6c6ebd3735a5b1b11e0e534e7352fa3ea642a852 Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 3 Sep 2015 10:00:59 -0400 Subject: [PATCH 24/49] Update .travis.yml --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index e368c59..ed95df8 100644 --- a/.travis.yml +++ b/.travis.yml @@ -5,7 +5,7 @@ compiler: - clang install: - - sudo apt-get install -y libjson-c-dev libcurl4-gnutls-dev libltdl-dev + - sudo apt-get install -y libjson0 libjson0-dev libcurl4-gnutls-dev libltdl-dev script: - mkdir -p build From e73671487d8669c1370913575219a14f5b26a01c Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 3 Sep 2015 10:05:53 -0400 Subject: [PATCH 25/49] Update .travis.yml --- .travis.yml | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index ed95df8..8de26a2 100644 --- a/.travis.yml +++ b/.travis.yml @@ -4,8 +4,10 @@ compiler: - gcc - clang -install: - - sudo apt-get install -y libjson0 libjson0-dev libcurl4-gnutls-dev libltdl-dev +addons: + apt: + packages: + - libltdl-dev script: - mkdir -p build From 5f24c869345f968b0f07553b11f101cebcdaa5cd Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 3 Sep 2015 10:11:33 -0400 Subject: [PATCH 26/49] Update .travis.yml --- .travis.yml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/.travis.yml b/.travis.yml index 8de26a2..73fffa0 100644 --- a/.travis.yml +++ b/.travis.yml @@ -7,9 +7,13 @@ compiler: addons: apt: packages: + - libltdl - libltdl-dev script: + - ls /usr/lib/libltdl* + - ls /usr/lib/libcurl* + - ls /usr/lib/libjs* - mkdir -p build - cd build - cmake .. From 7a8a47527871f8b964fc07a63c500664c3346905 Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 3 Sep 2015 11:27:27 -0400 Subject: [PATCH 27/49] Update FindCURL.cmake --- .cmake-modules/FindCURL.cmake | 1 + 1 file changed, 1 insertion(+) diff --git a/.cmake-modules/FindCURL.cmake b/.cmake-modules/FindCURL.cmake index d2e7b08..3d4ff13 100644 --- a/.cmake-modules/FindCURL.cmake +++ b/.cmake-modules/FindCURL.cmake @@ -27,6 +27,7 @@ FIND_LIBRARY(CURL_LIBRARY NAMES curl libcurl_imp PATHS "$ENV{LIB_DIR}/lib" /usr/local/lib /usr/lib + /usr/lib64 c:/msys/lib /usr/x86_64-w64-mingw32/lib /usr/i686-w64-mingw32/lib From 4a394c4aee38d616441a892dd72bd74dd1d467df Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 3 Sep 2015 11:33:20 -0400 Subject: [PATCH 28/49] Update FindCURL.cmake --- .cmake-modules/FindCURL.cmake | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/.cmake-modules/FindCURL.cmake b/.cmake-modules/FindCURL.cmake index 3d4ff13..cc37dd7 100644 --- a/.cmake-modules/FindCURL.cmake +++ b/.cmake-modules/FindCURL.cmake @@ -5,6 +5,14 @@ # CURL_LIBRARIES - List of libraries when using curl. # CURL_FOUND - True if curl found. +# use pkg-config to get the directories and then use these values +# in the FIND_PATH() and FIND_LIBRARY() calls +if(NOT WIN32) + find_package(PkgConfig) + pkg_check_modules(PC_CURL curl) + set(CURL_DEFINITIONS ${PC_CURL_CFLAGS_OTHER}) +endif(NOT WIN32) + # Look for the header file. FIND_PATH(CURL_INCLUDE_DIR curl/curl.h $ENV{INCLUDE} @@ -22,7 +30,7 @@ FIND_PATH(CURL_INCLUDE_DIR curl/curl.h MARK_AS_ADVANCED(CURL_INCLUDE_DIR) # Look for the library. -FIND_LIBRARY(CURL_LIBRARY NAMES curl libcurl_imp PATHS +find_library(CURL_LIBRARY NAMES curl libcurl_imp PATHS $ENV{LIB} "$ENV{LIB_DIR}/lib" /usr/local/lib @@ -31,6 +39,9 @@ FIND_LIBRARY(CURL_LIBRARY NAMES curl libcurl_imp PATHS c:/msys/lib /usr/x86_64-w64-mingw32/lib /usr/i686-w64-mingw32/lib + HINTS + ${PC_CURL_LIBDIR} + ${PC_CURL_LIBRARY_DIRS} NO_DEFAULT_PATH ) From 1c9fc2e9f051261074407316eb5eeeb41fdbbb6c Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 3 Sep 2015 11:36:02 -0400 Subject: [PATCH 29/49] Update FindCURL.cmake --- .cmake-modules/FindCURL.cmake | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.cmake-modules/FindCURL.cmake b/.cmake-modules/FindCURL.cmake index cc37dd7..79add63 100644 --- a/.cmake-modules/FindCURL.cmake +++ b/.cmake-modules/FindCURL.cmake @@ -9,7 +9,7 @@ # in the FIND_PATH() and FIND_LIBRARY() calls if(NOT WIN32) find_package(PkgConfig) - pkg_check_modules(PC_CURL curl) + pkg_check_modules(PC_CURL libcurl) set(CURL_DEFINITIONS ${PC_CURL_CFLAGS_OTHER}) endif(NOT WIN32) From b49d5726a413cf1490c1f4bb080c1eb95e41dd39 Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 3 Sep 2015 11:46:41 -0400 Subject: [PATCH 30/49] updated cmake scripts for travis --- .cmake-modules/FindJSONC.cmake | 15 ++++++++++++--- .cmake-modules/FindLTDL.cmake | 11 +++++++++++ .travis.yml | 6 ++++-- 3 files changed, 27 insertions(+), 5 deletions(-) diff --git a/.cmake-modules/FindJSONC.cmake b/.cmake-modules/FindJSONC.cmake index a2e59d9..3303f5e 100644 --- a/.cmake-modules/FindJSONC.cmake +++ b/.cmake-modules/FindJSONC.cmake @@ -1,9 +1,15 @@ # - Find json-c # Find the native JSONC headers and libraries. # -# JSONC_INCLUDE_DIRS - where to find curl/curl.h, etc. -# JSONC_LIBRARIES - List of libraries when using curl. -# JSONC_FOUND - True if curl found. +# JSONC_INCLUDE_DIRS - where to find jsonc/jsonc.h, etc. +# JSONC_LIBRARIES - List of libraries when using jsonc. +# JSONC_FOUND - True if jsonc found. + +if(NOT WIN32) + find_package(PkgConfig) + pkg_check_modules(PC_JSONC json-c) + set(JSONC_DEFINITIONS ${PC_JSONC_CFLAGS_OTHER}) +endif(NOT WIN32) # Look for the header file. FIND_PATH(JSONC_INCLUDE_DIR json-c/json.h @@ -30,6 +36,9 @@ FIND_LIBRARY(JSONC_LIBRARY NAMES json-c libjson-c PATHS c:/msys/lib /usr/x86_64-w64-mingw32/lib /usr/i686-w64-mingw32/lib + HINTS + ${PC_JSONC_LIBDIR} + ${PC_JSONC_LIBRARY_DIRS} NO_DEFAULT_PATH ) diff --git a/.cmake-modules/FindLTDL.cmake b/.cmake-modules/FindLTDL.cmake index 9f0402f..ecf7639 100644 --- a/.cmake-modules/FindLTDL.cmake +++ b/.cmake-modules/FindLTDL.cmake @@ -5,6 +5,14 @@ # LTDL_LIBRARIES - List of libraries when using curl. # LTDL_FOUND - True if curl found. +# use pkg-config to get the directories and then use these values +# in the FIND_PATH() and FIND_LIBRARY() calls +if(NOT WIN32) + find_package(PkgConfig) + pkg_check_modules(PC_LTDL libcurl) + set(LTDL_DEFINITIONS ${PC_LTDL_CFLAGS_OTHER}) +endif(NOT WIN32) +s # Look for the header file. FIND_PATH(LTDL_INCLUDE_DIR ltdl.h $ENV{INCLUDE} @@ -30,6 +38,9 @@ FIND_LIBRARY(LTDL_LIBRARY NAMES ltdl libltdl PATHS c:/msys/bin /usr/x86_64-w64-mingw32/lib /usr/i686-w64-mingw32/lib + HINTS + ${PC_LTDL_LIBDIR} + ${PC_LTDL_LIBRARY_DIRS} NO_DEFAULT_PATH ) diff --git a/.travis.yml b/.travis.yml index 73fffa0..9370e99 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,4 +1,5 @@ language: c +sudo: false compiler: - gcc @@ -9,7 +10,8 @@ addons: packages: - libltdl - libltdl-dev - + - libtool + script: - ls /usr/lib/libltdl* - ls /usr/lib/libcurl* @@ -20,4 +22,4 @@ script: - make - sudo make install -#script: ./autogen.sh && ./configure && make +#script: ./autogen.sh && ./configure && make From 99976c9dfcd07348e24a4ebb0f9c88c090473f08 Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 3 Sep 2015 11:49:57 -0400 Subject: [PATCH 31/49] update cmake for travis --- .cmake-modules/FindJSONC.cmake | 2 +- .cmake-modules/FindLTDL.cmake | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/.cmake-modules/FindJSONC.cmake b/.cmake-modules/FindJSONC.cmake index 3303f5e..a0e3cbf 100644 --- a/.cmake-modules/FindJSONC.cmake +++ b/.cmake-modules/FindJSONC.cmake @@ -7,7 +7,7 @@ if(NOT WIN32) find_package(PkgConfig) - pkg_check_modules(PC_JSONC json-c) + pkg_check_modules(PC_JSONC json-c libjson-c) set(JSONC_DEFINITIONS ${PC_JSONC_CFLAGS_OTHER}) endif(NOT WIN32) diff --git a/.cmake-modules/FindLTDL.cmake b/.cmake-modules/FindLTDL.cmake index ecf7639..9ef9d1f 100644 --- a/.cmake-modules/FindLTDL.cmake +++ b/.cmake-modules/FindLTDL.cmake @@ -1,5 +1,5 @@ # - Find libltdl -# Find the native UV headers and libraries. +# Find the native ltdl headers and libraries. # # LTDL_INCLUDE_DIRS - where to find ltdl.h, etc. # LTDL_LIBRARIES - List of libraries when using curl. @@ -9,10 +9,10 @@ # in the FIND_PATH() and FIND_LIBRARY() calls if(NOT WIN32) find_package(PkgConfig) - pkg_check_modules(PC_LTDL libcurl) + pkg_check_modules(PC_LTDL ltdl) set(LTDL_DEFINITIONS ${PC_LTDL_CFLAGS_OTHER}) endif(NOT WIN32) -s + # Look for the header file. FIND_PATH(LTDL_INCLUDE_DIR ltdl.h $ENV{INCLUDE} From 8a45ef47f2cc123d9379d87a6e40064f8d2a6c5d Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 3 Sep 2015 11:56:28 -0400 Subject: [PATCH 32/49] updated travis build configuration --- .travis.yml | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/.travis.yml b/.travis.yml index 9370e99..fa1dd78 100644 --- a/.travis.yml +++ b/.travis.yml @@ -8,18 +8,23 @@ compiler: addons: apt: packages: - - libltdl - libltdl-dev - libtool + - libjson-c-dev + - libjson-c2 + +install: + - libtoolize -c + - cd libltdl + - ./configure + - make && make install script: - - ls /usr/lib/libltdl* - - ls /usr/lib/libcurl* - - ls /usr/lib/libjs* + - ls /usr/lib64 - mkdir -p build - cd build - cmake .. - make - - sudo make install + - make install #script: ./autogen.sh && ./configure && make From ca1e7f7887902d72f2c67f90c068596fa375e8ba Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 3 Sep 2015 12:01:08 -0400 Subject: [PATCH 33/49] Update .travis.yml --- .travis.yml | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/.travis.yml b/.travis.yml index fa1dd78..f3e7bc1 100644 --- a/.travis.yml +++ b/.travis.yml @@ -8,16 +8,17 @@ compiler: addons: apt: packages: + - libltdl7 - libltdl-dev - libtool - - libjson-c-dev - - libjson-c2 + - libjson0 + - libjson0-dev -install: - - libtoolize -c - - cd libltdl - - ./configure - - make && make install +#install: +# - libtoolize -c +# - cd libltdl +# - ./configure +# - make && make install script: - ls /usr/lib64 From 604211d49a7e97e008f7ff700250ac7304c3153d Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 3 Sep 2015 12:05:50 -0400 Subject: [PATCH 34/49] Update FindJSONC.cmake --- .cmake-modules/FindJSONC.cmake | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.cmake-modules/FindJSONC.cmake b/.cmake-modules/FindJSONC.cmake index a0e3cbf..9ce7a4e 100644 --- a/.cmake-modules/FindJSONC.cmake +++ b/.cmake-modules/FindJSONC.cmake @@ -27,12 +27,13 @@ FIND_PATH(JSONC_INCLUDE_DIR json-c/json.h MARK_AS_ADVANCED(JSONC_INCLUDE_DIR) # Look for the library. -FIND_LIBRARY(JSONC_LIBRARY NAMES json-c libjson-c PATHS +FIND_LIBRARY(JSONC_LIBRARY NAMES json-c libjson-c libjson PATHS $ENV{LIB} $ENV{PATH} "$ENV{LIB_DIR}/lib" /usr/local/lib /usr/lib + /usr/lib/x86_64-linux-gnu c:/msys/lib /usr/x86_64-w64-mingw32/lib /usr/i686-w64-mingw32/lib From 8b21d887590d89b700ed71338a7edebdd220c76b Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 3 Sep 2015 12:06:20 -0400 Subject: [PATCH 35/49] Update FindLTDL.cmake --- .cmake-modules/FindLTDL.cmake | 1 + 1 file changed, 1 insertion(+) diff --git a/.cmake-modules/FindLTDL.cmake b/.cmake-modules/FindLTDL.cmake index 9ef9d1f..f433be0 100644 --- a/.cmake-modules/FindLTDL.cmake +++ b/.cmake-modules/FindLTDL.cmake @@ -33,6 +33,7 @@ FIND_LIBRARY(LTDL_LIBRARY NAMES ltdl libltdl PATHS $ENV{LIB} "$ENV{LIB_DIR}/lib" /usr/local/lib + /usr/lib/x86_64-linux-gnu /usr/lib c:/msys/lib c:/msys/bin From a1cc222273fde778dc50663032309f4691a08ae1 Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 3 Sep 2015 12:12:50 -0400 Subject: [PATCH 36/49] travis --- .cmake-modules/FindJSONC.cmake | 11 ++--------- .cmake-modules/FindLTDL.cmake | 11 ++--------- .travis.yml | 5 +---- 3 files changed, 5 insertions(+), 22 deletions(-) diff --git a/.cmake-modules/FindJSONC.cmake b/.cmake-modules/FindJSONC.cmake index 9ce7a4e..bd14472 100644 --- a/.cmake-modules/FindJSONC.cmake +++ b/.cmake-modules/FindJSONC.cmake @@ -5,11 +5,6 @@ # JSONC_LIBRARIES - List of libraries when using jsonc. # JSONC_FOUND - True if jsonc found. -if(NOT WIN32) - find_package(PkgConfig) - pkg_check_modules(PC_JSONC json-c libjson-c) - set(JSONC_DEFINITIONS ${PC_JSONC_CFLAGS_OTHER}) -endif(NOT WIN32) # Look for the header file. FIND_PATH(JSONC_INCLUDE_DIR json-c/json.h @@ -27,19 +22,17 @@ FIND_PATH(JSONC_INCLUDE_DIR json-c/json.h MARK_AS_ADVANCED(JSONC_INCLUDE_DIR) # Look for the library. -FIND_LIBRARY(JSONC_LIBRARY NAMES json-c libjson-c libjson PATHS +FIND_LIBRARY(JSONC_LIBRARY NAMES json-c libjson-c libjson libjson PATHS $ENV{LIB} $ENV{PATH} "$ENV{LIB_DIR}/lib" /usr/local/lib /usr/lib /usr/lib/x86_64-linux-gnu + /usr/lib/i386-linux-gnu c:/msys/lib /usr/x86_64-w64-mingw32/lib /usr/i686-w64-mingw32/lib - HINTS - ${PC_JSONC_LIBDIR} - ${PC_JSONC_LIBRARY_DIRS} NO_DEFAULT_PATH ) diff --git a/.cmake-modules/FindLTDL.cmake b/.cmake-modules/FindLTDL.cmake index f433be0..3691e27 100644 --- a/.cmake-modules/FindLTDL.cmake +++ b/.cmake-modules/FindLTDL.cmake @@ -5,14 +5,6 @@ # LTDL_LIBRARIES - List of libraries when using curl. # LTDL_FOUND - True if curl found. -# use pkg-config to get the directories and then use these values -# in the FIND_PATH() and FIND_LIBRARY() calls -if(NOT WIN32) - find_package(PkgConfig) - pkg_check_modules(PC_LTDL ltdl) - set(LTDL_DEFINITIONS ${PC_LTDL_CFLAGS_OTHER}) -endif(NOT WIN32) - # Look for the header file. FIND_PATH(LTDL_INCLUDE_DIR ltdl.h $ENV{INCLUDE} @@ -33,8 +25,9 @@ FIND_LIBRARY(LTDL_LIBRARY NAMES ltdl libltdl PATHS $ENV{LIB} "$ENV{LIB_DIR}/lib" /usr/local/lib - /usr/lib/x86_64-linux-gnu /usr/lib + /usr/lib/x86_64-linux-gnu + /usr/lib/i386-linux-gnu c:/msys/lib c:/msys/bin /usr/x86_64-w64-mingw32/lib diff --git a/.travis.yml b/.travis.yml index f3e7bc1..05ac131 100644 --- a/.travis.yml +++ b/.travis.yml @@ -8,10 +8,7 @@ compiler: addons: apt: packages: - - libltdl7 - libltdl-dev - - libtool - - libjson0 - libjson0-dev #install: @@ -21,7 +18,7 @@ addons: # - make && make install script: - - ls /usr/lib64 + - ls /usr/lib/*-linux-gnu - mkdir -p build - cd build - cmake .. From 29d2b2d6159ed910468f33e4d872c6ff2e3ce6dd Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 3 Sep 2015 12:25:39 -0400 Subject: [PATCH 37/49] build json-c from source --- .travis.yml | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/.travis.yml b/.travis.yml index 05ac131..251ef8f 100644 --- a/.travis.yml +++ b/.travis.yml @@ -11,11 +11,11 @@ addons: - libltdl-dev - libjson0-dev -#install: -# - libtoolize -c -# - cd libltdl -# - ./configure -# - make && make install +install: + - wget https://github.com/json-c/json-c/archive/json-c-0.12-20140410.tar.gz + - tar -xzvf json-c-0.12-20140410.tar.gz + - cd json-c-json-c-0.12-20140410 + - ./configure && make && make install script: - ls /usr/lib/*-linux-gnu From 176082b1473ba2abde83aaf79b72a3c86016395a Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 3 Sep 2015 12:31:13 -0400 Subject: [PATCH 38/49] travis --- .travis.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 251ef8f..40a0f28 100644 --- a/.travis.yml +++ b/.travis.yml @@ -15,7 +15,9 @@ install: - wget https://github.com/json-c/json-c/archive/json-c-0.12-20140410.tar.gz - tar -xzvf json-c-0.12-20140410.tar.gz - cd json-c-json-c-0.12-20140410 - - ./configure && make && make install + - ./configure + - CC="-Wno-error=unused-but-set-variable" make + - make install script: - ls /usr/lib/*-linux-gnu From bbe5b7b1e7675854760935df6fc9b864d3e03c17 Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 3 Sep 2015 12:33:04 -0400 Subject: [PATCH 39/49] travis --- .travis.yml | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/.travis.yml b/.travis.yml index 40a0f28..29c48b9 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,5 +1,5 @@ language: c -sudo: false +sudo: required compiler: - gcc @@ -15,9 +15,9 @@ install: - wget https://github.com/json-c/json-c/archive/json-c-0.12-20140410.tar.gz - tar -xzvf json-c-0.12-20140410.tar.gz - cd json-c-json-c-0.12-20140410 - - ./configure + - ./configure --prefix=/usr - CC="-Wno-error=unused-but-set-variable" make - - make install + - sudo make install script: - ls /usr/lib/*-linux-gnu From 6e860c40688960a8ebeee333a3abba42c528fe86 Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 3 Sep 2015 12:37:49 -0400 Subject: [PATCH 40/49] travis --- .travis.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.travis.yml b/.travis.yml index 29c48b9..796d022 100644 --- a/.travis.yml +++ b/.travis.yml @@ -12,12 +12,14 @@ addons: - libjson0-dev install: + - cd .. - wget https://github.com/json-c/json-c/archive/json-c-0.12-20140410.tar.gz - tar -xzvf json-c-0.12-20140410.tar.gz - cd json-c-json-c-0.12-20140410 - ./configure --prefix=/usr - CC="-Wno-error=unused-but-set-variable" make - sudo make install + - cd ../syncd script: - ls /usr/lib/*-linux-gnu From c99c4402c04ce996098b1229ab8d2614d6128772 Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 3 Sep 2015 12:46:27 -0400 Subject: [PATCH 41/49] travis --- .travis.yml | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/.travis.yml b/.travis.yml index 796d022..eaf8710 100644 --- a/.travis.yml +++ b/.travis.yml @@ -9,7 +9,6 @@ addons: apt: packages: - libltdl-dev - - libjson0-dev install: - cd .. @@ -17,7 +16,7 @@ install: - tar -xzvf json-c-0.12-20140410.tar.gz - cd json-c-json-c-0.12-20140410 - ./configure --prefix=/usr - - CC="-Wno-error=unused-but-set-variable" make + - CFLAGS="-Wno-error=unused-but-set-variable" make - sudo make install - cd ../syncd From e90468b8a45c8b3966bf6fd228fb40cc9258058f Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 3 Sep 2015 13:01:35 -0400 Subject: [PATCH 42/49] travis --- .cmake-modules/FindJSONC.cmake | 2 +- .travis.yml | 26 ++++++++++---------------- install_jsonc.sh | 15 +++++++++++++++ 3 files changed, 26 insertions(+), 17 deletions(-) create mode 100644 install_jsonc.sh diff --git a/.cmake-modules/FindJSONC.cmake b/.cmake-modules/FindJSONC.cmake index bd14472..cd42f29 100644 --- a/.cmake-modules/FindJSONC.cmake +++ b/.cmake-modules/FindJSONC.cmake @@ -22,7 +22,7 @@ FIND_PATH(JSONC_INCLUDE_DIR json-c/json.h MARK_AS_ADVANCED(JSONC_INCLUDE_DIR) # Look for the library. -FIND_LIBRARY(JSONC_LIBRARY NAMES json-c libjson-c libjson libjson PATHS +FIND_LIBRARY(JSONC_LIBRARY NAMES json-c libjson-c PATHS $ENV{LIB} $ENV{PATH} "$ENV{LIB_DIR}/lib" diff --git a/.travis.yml b/.travis.yml index eaf8710..cb6ff2c 100644 --- a/.travis.yml +++ b/.travis.yml @@ -1,31 +1,25 @@ language: c -sudo: required + +sudo: false + +cache: + directories: $HOME/jsonc compiler: - gcc - clang -addons: - apt: - packages: - - libltdl-dev - install: - - cd .. - - wget https://github.com/json-c/json-c/archive/json-c-0.12-20140410.tar.gz - - tar -xzvf json-c-0.12-20140410.tar.gz - - cd json-c-json-c-0.12-20140410 - - ./configure --prefix=/usr - - CFLAGS="-Wno-error=unused-but-set-variable" make - - sudo make install - - cd ../syncd + - sh ./install_jsonc.sh script: - - ls /usr/lib/*-linux-gnu + - ls -r $HOME/jsonc + - export INCLUDE="$HOME/jsonc/include" + - export LIB="$HOME/jsonc/lib" + - export CFLAGS="-L$HOME/jsonc/lib -I$HOME/jsonc/include" - mkdir -p build - cd build - cmake .. - make - - make install #script: ./autogen.sh && ./configure && make diff --git a/install_jsonc.sh b/install_jsonc.sh new file mode 100644 index 0000000..a450b07 --- /dev/null +++ b/install_jsonc.sh @@ -0,0 +1,15 @@ +#!bin/sh +set -e +if [! -d "$HOME/jsonc/lib" ]; then + cd .. + wget https://github.com/json-c/json-c/archive/json-c-0.12-20140410.tar.gz + tar -xzvf json-c-0.12-20140410.tar.gz + cd json-c-json-c-0.12-20140410 + CC="clang" + export CCFLAGS="-Wno-error=unused-but-set-variable" + ./configure --prefix=$HOME/jsonc + make + make install +else + echo 'Using cached copy of json-c.'; +fi From b78b8e1c3fc78ca5d7ad47bd6d3aef82c16bf1e7 Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 3 Sep 2015 13:04:07 -0400 Subject: [PATCH 43/49] travis --- install_jsonc.sh | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) mode change 100644 => 100755 install_jsonc.sh diff --git a/install_jsonc.sh b/install_jsonc.sh old mode 100644 new mode 100755 index a450b07..9e8ee06 --- a/install_jsonc.sh +++ b/install_jsonc.sh @@ -1,6 +1,6 @@ -#!bin/sh +#!/bin/sh set -e -if [! -d "$HOME/jsonc/lib" ]; then +if [ ! -d "$HOME/jsonc/lib" ]; then cd .. wget https://github.com/json-c/json-c/archive/json-c-0.12-20140410.tar.gz tar -xzvf json-c-0.12-20140410.tar.gz From 5f2ef2d09a95193f1033b3e38dc305947d541746 Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 3 Sep 2015 13:09:31 -0400 Subject: [PATCH 44/49] travis --- libdropbox/CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libdropbox/CMakeLists.txt b/libdropbox/CMakeLists.txt index 075037f..141ad7b 100644 --- a/libdropbox/CMakeLists.txt +++ b/libdropbox/CMakeLists.txt @@ -4,5 +4,5 @@ include_directories("${CMAKE_ROOT}") #target_link_libraries(dropbox_main LINK_PRIVATE rest ${JSONC_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ) add_library(dropbox dropbox_api.c) -set_property(TARGET dropbox PROPERTY POSITION_INDEPENDENT_CODE ON) +set_target_properties(dropbox PROPERTIES POSITION_INDEPENDENT_CODE ON) target_link_libraries(dropbox LINK_PRIVATE rest ${JSONC_LIBRARIES}) From ac539cebf30c579469a2fc175bd947797dfc42aa Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 3 Sep 2015 13:14:46 -0400 Subject: [PATCH 45/49] travis --- libdropbox/CMakeLists.txt | 2 +- libgdrive/CMakeLists.txt | 1 + librest/CMakeLists.txt | 1 + 3 files changed, 3 insertions(+), 1 deletion(-) diff --git a/libdropbox/CMakeLists.txt b/libdropbox/CMakeLists.txt index 141ad7b..3afc056 100644 --- a/libdropbox/CMakeLists.txt +++ b/libdropbox/CMakeLists.txt @@ -1,8 +1,8 @@ include_directories("${CMAKE_ROOT}") +set(POSITION_INDEPENDENT_CODE TRUE) #add_executable(dropbox_main dropbox_api.c dropbox_main.c) #target_link_libraries(dropbox_main LINK_PRIVATE rest ${JSONC_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ) add_library(dropbox dropbox_api.c) -set_target_properties(dropbox PROPERTIES POSITION_INDEPENDENT_CODE ON) target_link_libraries(dropbox LINK_PRIVATE rest ${JSONC_LIBRARIES}) diff --git a/libgdrive/CMakeLists.txt b/libgdrive/CMakeLists.txt index 2183d9c..b9338ac 100644 --- a/libgdrive/CMakeLists.txt +++ b/libgdrive/CMakeLists.txt @@ -1,4 +1,5 @@ include_directories("${CMAKE_ROOT}") +set(POSITION_INDEPENDENT_CODE TRUE) #add_executable(gdrive_main gdrive_main.c gdrive_api.c) #target_link_libraries(gdrive_main LINK_PRIVATE rest ${JSONC_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT}) diff --git a/librest/CMakeLists.txt b/librest/CMakeLists.txt index d1381e6..c84c504 100644 --- a/librest/CMakeLists.txt +++ b/librest/CMakeLists.txt @@ -1,4 +1,5 @@ find_package(CURL) +set(POSITION_INDEPENDENT_CODE TRUE) include_directories(${CURL_INCLUDE_DIRS}) add_library(rest rest.c buffer.c) From 66fe2059fc18dd23976caa3e74f902da800b91ea Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Thu, 3 Sep 2015 13:23:41 -0400 Subject: [PATCH 46/49] travis --- .travis.yml | 2 +- libdropbox/CMakeLists.txt | 1 - libgdrive/CMakeLists.txt | 1 - librest/CMakeLists.txt | 1 - 4 files changed, 1 insertion(+), 4 deletions(-) diff --git a/.travis.yml b/.travis.yml index cb6ff2c..695d6c2 100644 --- a/.travis.yml +++ b/.travis.yml @@ -16,7 +16,7 @@ script: - ls -r $HOME/jsonc - export INCLUDE="$HOME/jsonc/include" - export LIB="$HOME/jsonc/lib" - - export CFLAGS="-L$HOME/jsonc/lib -I$HOME/jsonc/include" + - export CFLAGS="$CFLAGS -fPIC" - mkdir -p build - cd build - cmake .. diff --git a/libdropbox/CMakeLists.txt b/libdropbox/CMakeLists.txt index 3afc056..6c82d65 100644 --- a/libdropbox/CMakeLists.txt +++ b/libdropbox/CMakeLists.txt @@ -1,5 +1,4 @@ include_directories("${CMAKE_ROOT}") -set(POSITION_INDEPENDENT_CODE TRUE) #add_executable(dropbox_main dropbox_api.c dropbox_main.c) #target_link_libraries(dropbox_main LINK_PRIVATE rest ${JSONC_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ) diff --git a/libgdrive/CMakeLists.txt b/libgdrive/CMakeLists.txt index b9338ac..2183d9c 100644 --- a/libgdrive/CMakeLists.txt +++ b/libgdrive/CMakeLists.txt @@ -1,5 +1,4 @@ include_directories("${CMAKE_ROOT}") -set(POSITION_INDEPENDENT_CODE TRUE) #add_executable(gdrive_main gdrive_main.c gdrive_api.c) #target_link_libraries(gdrive_main LINK_PRIVATE rest ${JSONC_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT}) diff --git a/librest/CMakeLists.txt b/librest/CMakeLists.txt index c84c504..d1381e6 100644 --- a/librest/CMakeLists.txt +++ b/librest/CMakeLists.txt @@ -1,5 +1,4 @@ find_package(CURL) -set(POSITION_INDEPENDENT_CODE TRUE) include_directories(${CURL_INCLUDE_DIRS}) add_library(rest rest.c buffer.c) From 94788b1b7fadd77f4a5af1f886626d6be1dbd3f3 Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Sun, 4 Oct 2015 23:29:31 -0400 Subject: [PATCH 47/49] added flock locking where available --- CMakeLists.txt | 2 ++ cmake-config.h.in | 4 ++++ libdropbox/CMakeLists.txt | 1 + libgdrive/CMakeLists.txt | 2 +- librest/CMakeLists.txt | 2 +- src/CMakeLists.txt | 16 ++++++++++++--- src/cache.c | 41 ++++++++++++++++++++++---------------- src/test | Bin 162601 -> 9012 bytes 8 files changed, 46 insertions(+), 22 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 599ddbe..c32b0c1 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -16,10 +16,12 @@ check_include_files("sys/inotify.h" HAVE_INOTIFY_H) check_include_files("err.h" HAVE_ERR_H) check_include_files("sys/wait.h" HAVE_WAIT_H) check_function_exists(fork HAVE_FORK) +check_function_exists(flock HAVE_FLOCK) include_directories("${CMAKE_BINARY_DIR}") include_directories("${CMAKE_CURRENT_LIST_DIR}") + set(PLUGIN_DIR "${CMAKE_INSTALL_PREFIX}/lib/syncd/plugins") add_subdirectory(librest) add_subdirectory(libdropbox) diff --git a/cmake-config.h.in b/cmake-config.h.in index b8eabfa..e31489b 100644 --- a/cmake-config.h.in +++ b/cmake-config.h.in @@ -3,6 +3,10 @@ #cmakedefine HAVE_ERR_H 1 #cmakedefine HAVE_FORK 1 #cmakedefine HAVE_WAIT_H 1 +#cmakedefine HAVE_FLOCK 1 + +#cmakedefine USE_FLOCK_LK ${USE_FLOCK_LK} +#cmakedefine USE_SEMAPHORE_LK ${USE_SEMAPHORE_LK} // Set Up Directories #define LIBDIR "${PLUGIN_DIR}" diff --git a/libdropbox/CMakeLists.txt b/libdropbox/CMakeLists.txt index 6c82d65..238e502 100644 --- a/libdropbox/CMakeLists.txt +++ b/libdropbox/CMakeLists.txt @@ -4,4 +4,5 @@ include_directories("${CMAKE_ROOT}") #target_link_libraries(dropbox_main LINK_PRIVATE rest ${JSONC_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ) add_library(dropbox dropbox_api.c) +set_property(TARGET dropbox PROPERTY POSITION_INDEPENDENT_CODE True) target_link_libraries(dropbox LINK_PRIVATE rest ${JSONC_LIBRARIES}) diff --git a/libgdrive/CMakeLists.txt b/libgdrive/CMakeLists.txt index 2183d9c..ccff9db 100644 --- a/libgdrive/CMakeLists.txt +++ b/libgdrive/CMakeLists.txt @@ -4,5 +4,5 @@ include_directories("${CMAKE_ROOT}") #target_link_libraries(gdrive_main LINK_PRIVATE rest ${JSONC_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT}) add_library(gdrive gdrive_api.c) -set_property(TARGET gdrive PROPERTY POSITION_INDEPENDENT_CODE ON) +set_property(TARGET gdrive PROPERTY POSITION_INDEPENDENT_CODE True) target_link_libraries(gdrive LINK_PRIVATE rest ${JSONC_LIBRARIES}) diff --git a/librest/CMakeLists.txt b/librest/CMakeLists.txt index d1381e6..ddcfd7f 100644 --- a/librest/CMakeLists.txt +++ b/librest/CMakeLists.txt @@ -2,7 +2,7 @@ find_package(CURL) include_directories(${CURL_INCLUDE_DIRS}) add_library(rest rest.c buffer.c) -set_property(TARGET rest PROPERTY POSITION_INDEPENDENT_CODE ON) +set_property(TARGET rest PROPERTY POSITION_INDEPENDENT_CODE True) target_link_libraries(rest LINK_PUBLIC ${CURL_LIBRARIES}) if(WIN32) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 24504ac..70594cc 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -2,19 +2,29 @@ find_package(LTDL) include_directories("${CMAKE_CURRENT_LIST_DIR}") include_directories("${LTDL_INCLUDE_DIRS}") +if(HAVE_FLOCK) + OPTION(USE_FLOCK_LK "Use Flock for database locking" ON) + OPTION(USE_SEMAPHORE_LK "Use Semaphores for database locking" OFF) +else() + set(USE_SEMAPHORE_LK, 1) +endif() + IF(WIN32) find_package(mman) set(SHARED_MEM "${MMAN_LIBRARIES}") + set(LOCK_DEPS "ipc_semaphore.c") ELSEIF(UNIX AND NOT APPLE) set(SHARED_MEM "rt") + set(LOCK_DEPS "") ELSE() - set(SHARED_MEM "") + set(SHARED_MEM "") + set(LOCK_DEPS "") ENDIF() -add_executable(syncd syncd.c cache.c ipc_semaphore.c shared_memory.c json_helper.c log.c) +add_executable(syncd syncd.c cache.c lock.c ${LOCK_DEPS} shared_memory.c json_helper.c log.c) target_link_libraries(syncd LINK_PRIVATE ${CMAKE_THREAD_LIBS_INIT} ${LTDL_LIBRARIES} ${JSONC_LIBRARIES} ${SHARED_MEM}) -add_executable(testPlugin testPlugin.c cache.c ipc_semaphore.c shared_memory.c json_helper.c log.c) +add_executable(testPlugin testPlugin.c cache.c lock.c ${LOCK_DEPS} shared_memory.c json_helper.c log.c) target_link_libraries(testPlugin LINK_PRIVATE ${CMAKE_THREAD_LIBS_INIT} ${LTDL_LIBRARIES} ${JSONC_LIBRARIES} ${SHARED_MEM}) install(TARGETS syncd RUNTIME DESTINATION bin) diff --git a/src/cache.c b/src/cache.c index 46e7237..b8bf1f2 100644 --- a/src/cache.c +++ b/src/cache.c @@ -28,7 +28,7 @@ #include #include #include -#include "ipc_semaphore.h" +#include "lock.h" #include "shared_memory.h" #include "log.h" #include @@ -51,10 +51,12 @@ json_object * config; char * cacheFile; int cacheFD; +int configFD; + long long int * cacheVersion; size_t cacheLength; -semaphore cache_semaphore; -semaphore config_semaphore; +syncd_lock cache_lock; +syncd_lock config_lock; /* definition of local utility functions */ void update_cache(); @@ -68,17 +70,22 @@ void cache_init(){ //cacheLength = (size_t *) shared_mem_alloc(sizeof(size_t), "SYNCD\\cache_length"); cacheLength = 10 * 1024 * 1024; // 10 MB for now. char path[PATH_MAX]; - strcpy(path, getenv("HOME")); + + strcpy(path, getenv("HOME")); strcat(path, "/.cache/syncd/cache.json"); int cacheFD = open(path,O_CREAT|O_RDWR, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP); + cache_lock = syncd_lock_create(path, cacheFD); ftruncate(cacheFD,cacheLength); logging_log(LOGARGS,"fd = %d\n",cacheFD); cacheFile = (char *) mmap(NULL, cacheLength, PROT_READ | PROT_WRITE, MAP_FILE|MAP_SHARED, cacheFD, 0); if (cacheFile == MAP_FAILED ) errx(1,"failed"); - // setup semaphores. - cache_semaphore = semaphore_create(1, "SYNCD\\cache" ); - config_semaphore = semaphore_create(1, "SYNCD\\config"); + + + strcpy(path, getenv("HOME")); + strcat(path, "/.cache/syncd/config.json"); + int configFD = open(path,O_CREAT|O_RDWR, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP); + config_lock = syncd_lock_create(path, configFD); } void cache_clear(){ @@ -86,8 +93,8 @@ void cache_clear(){ close(cacheFD); json_object_put(config); json_object_put(cache); - semaphore_delete(cache_semaphore , "SYNCD\\cache" ); - semaphore_delete(config_semaphore, "SYNCD\\config"); + syncd_lock_delete(cache_lock ); + syncd_lock_delete(config_lock); } json_object * getCache(const char * plugin_prefix){ @@ -192,9 +199,9 @@ utilities get_utility_functions(){ void update_cache(){ if (cache != NULL) json_object_put(cache); - semaphore_wait(cache_semaphore); + syncd_lock_wait(cache_lock, lock_shared); cache = json_tokener_parse(cacheFile); - semaphore_post(cache_semaphore); + syncd_lock_release(cache_lock, lock_shared); // cache = json_object_from_file("cache.json"); if (cache == NULL){ @@ -208,9 +215,9 @@ void update_config(){ strcpy(path,getenv("HOME")); strcat(path,"/.config/syncd/config.json"); - semaphore_wait(config_semaphore); + syncd_lock_wait(config_lock, lock_shared); config = json_object_from_file(path); - semaphore_post(config_semaphore); + syncd_lock_release(config_lock, lock_shared); if (config == NULL){ config = json_object_new_object(); @@ -226,10 +233,10 @@ void push_cache(){ if (strlen(string) > cacheLength){ logging_log(LOGARGS,"the string is too long\n"); } - semaphore_wait(cache_semaphore); + syncd_lock_wait(cache_lock, lock_exclusive); memcpy(cacheFile, string, strlen(string)); msync(cacheFile,strlen(string),MS_SYNC|MS_INVALIDATE); - semaphore_post(cache_semaphore); + syncd_lock_release(cache_lock, lock_exclusive); logging_log(LOGARGS,"cache pushed\n"); } @@ -237,7 +244,7 @@ void push_config(){ char path[PATH_MAX]; strcpy(path,getenv("HOME")); strcat(path,"/.config/syncd/config.json"); - semaphore_wait(config_semaphore); + syncd_lock_wait(config_lock, lock_exclusive); json_object_to_file(path,config); - semaphore_post(config_semaphore); + syncd_lock_release(config_lock, lock_exclusive); } diff --git a/src/test b/src/test index c54f2225c15440da264e90b41018123925de68a6..05b17147daad4e2b17978f5d415f86c7dcd8d97d 100644 GIT binary patch literal 9012 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 literal 162601 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 d`}hvSwD)_ Date: Sun, 4 Oct 2015 23:36:12 -0400 Subject: [PATCH 48/49] forgot to add files lock.c/lock.h --- src/lock.c | 64 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/lock.h | 33 ++++++++++++++++++++++++++++ 2 files changed, 97 insertions(+) create mode 100644 src/lock.c create mode 100644 src/lock.h diff --git a/src/lock.c b/src/lock.c new file mode 100644 index 0000000..bad3965 --- /dev/null +++ b/src/lock.c @@ -0,0 +1,64 @@ +#include "../build/config.h" +#include "lock.h" + + +#ifdef USE_FLOCK_LK +#include +#endif + +#ifdef USE_SEMAPHORE_LK +#include "ipc_semaphore.h" +#endif + +syncd_lock syncd_lock_create(const char * fname, int fd){ + syncd_lock lck; + + #ifdef USE_FLOCK_LK + lck.fd = fd; + #endif + #ifdef USE_SEMAPHORE_LK + lck.sem = semaphore_create(1, fname ); + #endif + return lck; +} + + +int syncd_lock_wait(syncd_lock lock, enum syncd_lock_type type){ +#ifdef USE_FLOCK_LK + int operation; + switch (type){ + case lock_shared: + operation = LOCK_SH; + break; + case lock_exclusive: + operation = LOCK_EX; + break; + default: + // this makes no sense. + return -1; + } + return flock(lock.fd, operation); +#endif + +#ifdef USE_SEMAPHORE_LK + return semaphore_wait(lock.sem); +#endif + return -1; +} + +int syncd_lock_release(syncd_lock lock, enum syncd_lock_type type){ +#if USE_FLOCK_LK + return flock(lock.fd, LOCK_UN); +#endif + +#ifdef USE_SEMAPHORE_LK + return semaphore_post(lock.sem); +#endif + return -1; +} + +void syncd_lock_delete(syncd_lock lock){ +#ifdef USE_SEMAPHORE_LK + semaphore_delete(lock.sem); +#endif +} diff --git a/src/lock.h b/src/lock.h new file mode 100644 index 0000000..d1a7668 --- /dev/null +++ b/src/lock.h @@ -0,0 +1,33 @@ +#ifndef SYNC_LOCK_H + +#ifdef USE_SEMAPHORE_LK +#include "ipc_semaphore.h" +#endif + +/*********** + * Define Lock type. This will map to some unrelying locking mechanism + */ + +enum syncd_lock_type { + lock_shared, + lock_exclusive +}; + +typedef struct { +#ifdef USE_FLOCK_LK + int fd; +#endif +#ifdef USE_SEMAPHORE_LK + semaphore sem; +#endif +} syncd_lock; + + +syncd_lock syncd_lock_create(const char * fname, int fd); + +int syncd_lock_wait (syncd_lock, enum syncd_lock_type); +int syncd_lock_release(syncd_lock, enum syncd_lock_type); + +void syncd_lock_delete(syncd_lock); + +#endif From 251d4c279ee340a2cbcff4518e11adbb609ead9e Mon Sep 17 00:00:00 2001 From: Paul Martin Date: Mon, 5 Oct 2015 20:13:33 -0400 Subject: [PATCH 49/49] commit to illustrate travis --- libexec/dropbox.c | 2 +- libexec/dropbox.h | 2 +- libexec/gdrive.c | 5 +++-- libexec/gdrive.h | 2 +- 4 files changed, 6 insertions(+), 5 deletions(-) diff --git a/libexec/dropbox.c b/libexec/dropbox.c index df4c38e..fe51e1f 100644 --- a/libexec/dropbox.c +++ b/libexec/dropbox.c @@ -268,7 +268,7 @@ void do_poll(int interval){ } -void watch_dir(const char* path){ +void sync_watch_dir(const char* path){ args.log(LOGARGS,"i am supposed to be monitoring directory %s\n",path); } diff --git a/libexec/dropbox.h b/libexec/dropbox.h index 5778b53..354b304 100644 --- a/libexec/dropbox.h +++ b/libexec/dropbox.h @@ -37,7 +37,7 @@ FILE * EXPORT_SHARED sync_open (const char* ); int EXPORT_SHARED sync_write (const char*,FILE * ); int EXPORT_SHARED sync_rm (const char* ); int EXPORT_SHARED sync_mv (const char*,const char* ); -void EXPORT_SHARED watch_dir (const char* ); +void EXPORT_SHARED sync_watch_dir (const char* ); int EXPORT_SHARED sync_mkdir (const char* ); void EXPORT_SHARED sync_unload ( ); const char * EXPORT_SHARED get_prefix ( ); diff --git a/libexec/gdrive.c b/libexec/gdrive.c index 8e2da72..562e25f 100644 --- a/libexec/gdrive.c +++ b/libexec/gdrive.c @@ -543,12 +543,13 @@ void sync_listen( int (*call_back)(const char*path,int type)){ * adds path to be watched for changes the plugin should only report changes * that occur in watched directories. */ -void watch_dir(const char * path){ +void sync_watch_dir(const char * path){ } /** FILE * sync_open( char * path ) -* opens path for reading, and returns a FILE handle to this resource. +* opens path for reading, and returns a FILE handle to this resourc + * e. * this file is not required to be seekable, ie it may be a pipe/stream. */ diff --git a/libexec/gdrive.h b/libexec/gdrive.h index 92f96d9..5a7fb51 100644 --- a/libexec/gdrive.h +++ b/libexec/gdrive.h @@ -40,7 +40,7 @@ FILE * EXPORT_SHARED sync_open (const char* ); int EXPORT_SHARED sync_write (const char*,FILE * ); int EXPORT_SHARED sync_rm (const char* ); int EXPORT_SHARED sync_mv (const char*,const char* ); -void EXPORT_SHARED watch_dir (const char* ); +void EXPORT_SHARED sync_watch_dir (const char* ); int EXPORT_SHARED sync_mkdir (const char* ); void EXPORT_SHARED sync_unload ( ); const char * EXPORT_SHARED get_prefix ( );